picrate 0.0.2-java

data/src/main/java/processing/core/PShapeOBJ.java

@@ -0,0 +1,544 @@
+package processing.core;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * This class is not part of the Processing API and should not be used
+ * directly. Instead, use loadShape() and methods like it, which will make
+ * use of this class. Using this class directly will cause your code to break
+ * when combined with future versions of Processing.
+ * <p>
+ * OBJ loading implemented using code from Saito's OBJLoader library:
+ * http://code.google.com/p/saitoobjloader/
+ * and OBJReader from Ahmet Kizilay
+ * http://www.openprocessing.org/visuals/?visualID=191
+ *
+ */
+public class PShapeOBJ extends PShape {
+
+  /**
+   * Initializes a new OBJ Object with the given filename.
+     * @param parent
+     * @param filename
+   */
+  public PShapeOBJ(PApplet parent, String filename) {
+    this(parent, parent.createReader(filename), getBasePath(parent, filename));
+  }
+
+    /**
+     *
+     * @param parent
+     * @param reader
+     */
+    public PShapeOBJ(PApplet parent, BufferedReader reader) {
+    this(parent, reader, "");
+  }
+
+    /**
+     *
+     * @param parent
+     * @param reader
+     * @param basePath
+     */
+    public PShapeOBJ(PApplet parent, BufferedReader reader, String basePath) {
+    ArrayList<OBJFace> faces = new ArrayList<OBJFace>();
+    ArrayList<OBJMaterial> materials = new ArrayList<OBJMaterial>();
+    ArrayList<PVector> coords = new ArrayList<PVector>();
+    ArrayList<PVector> normals = new ArrayList<PVector>();
+    ArrayList<PVector> texcoords = new ArrayList<PVector>();
+    parseOBJ(parent, basePath, reader,
+             faces, materials, coords, normals, texcoords);
+
+    // The OBJ geometry is stored with each face in a separate child shape.
+    parent = null;
+    family = GROUP;
+    addChildren(faces, materials, coords, normals, texcoords);
+  }
+
+    /**
+     *
+     * @param face
+     * @param mtl
+     * @param coords
+     * @param normals
+     * @param texcoords
+     */
+    protected PShapeOBJ(OBJFace face, OBJMaterial mtl,
+                      ArrayList<PVector> coords,
+                      ArrayList<PVector> normals,
+                      ArrayList<PVector> texcoords) {
+    family = GEOMETRY;
+    if (face.vertIdx.size() == 3) {
+      kind = TRIANGLES;
+    } else if (face.vertIdx.size() == 4) {
+      kind = QUADS;
+    } else {
+      kind = POLYGON;
+    }
+
+    stroke = false;
+    fill = true;
+
+    // Setting material properties for the new face
+    fillColor = rgbaValue(mtl.kd);
+    ambientColor = rgbaValue(mtl.ka);
+    specularColor = rgbaValue(mtl.ks);
+    shininess = mtl.ns;
+    if (mtl.kdMap != null) {
+      // If current material is textured, then tinting the texture using the
+      // diffuse color.
+      tintColor = rgbaValue(mtl.kd, mtl.d);
+    }
+
+    vertexCount = face.vertIdx.size();
+    vertices = new float[vertexCount][12];
+    for (int j = 0; j < face.vertIdx.size(); j++){
+      int vertIdx, normIdx, texIdx;
+      PVector vert, norms, tex;
+
+      vert = norms = tex = null;
+
+      vertIdx = face.vertIdx.get(j).intValue() - 1;
+      vert = coords.get(vertIdx);
+
+      if (j < face.normIdx.size()) {
+        normIdx = face.normIdx.get(j).intValue() - 1;
+        if (-1 < normIdx) {
+          norms = normals.get(normIdx);
+        }
+      }
+
+      if (j < face.texIdx.size()) {
+        texIdx = face.texIdx.get(j).intValue() - 1;
+        if (-1 < texIdx) {
+          tex = texcoords.get(texIdx);
+        }
+      }
+
+      vertices[j][X] = vert.x;
+      vertices[j][Y] = vert.y;
+      vertices[j][Z] = vert.z;
+
+      vertices[j][PGraphics.R] = mtl.kd.x;
+      vertices[j][PGraphics.G] = mtl.kd.y;
+      vertices[j][PGraphics.B] = mtl.kd.z;
+      vertices[j][PGraphics.A] = 1;
+
+      if (norms != null) {
+        vertices[j][PGraphics.NX] = norms.x;
+        vertices[j][PGraphics.NY] = norms.y;
+        vertices[j][PGraphics.NZ] = norms.z;
+      }
+
+      if (tex != null) {
+        vertices[j][PGraphics.U] = tex.x;
+        vertices[j][PGraphics.V] = tex.y;
+      }
+
+      if (mtl != null && mtl.kdMap != null) {
+        image = mtl.kdMap;
+      }
+    }
+  }
+
+    /**
+     *
+     * @param faces
+     * @param materials
+     * @param coords
+     * @param normals
+     * @param texcoords
+     */
+    protected void addChildren(ArrayList<OBJFace> faces,
+                             ArrayList<OBJMaterial> materials,
+                             ArrayList<PVector> coords,
+                             ArrayList<PVector> normals,
+                             ArrayList<PVector> texcoords) {
+    int mtlIdxCur = -1;
+    OBJMaterial mtl = null;
+    for (int i = 0; i < faces.size(); i++) {
+      OBJFace face = faces.get(i);
+
+      // Getting current material.
+      if (mtlIdxCur != face.matIdx || face.matIdx == -1) {
+        // To make sure that at least we get the default material
+        mtlIdxCur = PApplet.max(0, face.matIdx);
+        mtl = materials.get(mtlIdxCur);
+      }
+
+      // Creating child shape for current face.
+      PShape child = new PShapeOBJ(face, mtl, coords, normals, texcoords);
+      addChild(child);
+    }
+  }
+
+    /**
+     *
+     * @param parent
+     * @param path
+     * @param reader
+     * @param faces
+     * @param materials
+     * @param coords
+     * @param normals
+     * @param texcoords
+     */
+    static protected void parseOBJ(PApplet parent, String path,
+                                 BufferedReader reader,
+                                 ArrayList<OBJFace> faces,
+                                 ArrayList<OBJMaterial> materials,
+                                 ArrayList<PVector> coords,
+                                 ArrayList<PVector> normals,
+                                 ArrayList<PVector> texcoords) {
+    Map<String, Integer> mtlTable  = new HashMap<String, Integer>();
+    int mtlIdxCur = -1;
+    boolean readv, readvn, readvt;
+    try {
+
+      readv = readvn = readvt = false;
+      String line;
+      String gname = "object";
+      while ((line = reader.readLine()) != null) {
+       // Parse the line.
+        line = line.trim();
+        if (line.equals("") || line.indexOf('#') == 0) {
+          // Empty line of comment, ignore line
+          continue;
+        }
+
+        // The below patch/hack comes from Carlos Tomas Marti and is a
+        // fix for single backslashes in Rhino obj files
+
+        // BEGINNING OF RHINO OBJ FILES HACK
+        // Statements can be broken in multiple lines using '\' at the
+        // end of a line.
+        // In regular expressions, the backslash is also an escape
+        // character.
+        // The regular expression \\ matches a single backslash. This
+        // regular expression as a Java string, becomes "\\\\".
+        // That's right: 4 backslashes to match a single one.
+        while (line.contains("\\")) {
+          line = line.split("\\\\")[0];
+          final String s = reader.readLine();
+          if (s != null)
+            line += s;
+        }
+        // END OF RHINO OBJ FILES HACK
+
+        String[] parts = line.split("\\s+");
+        // if not a blank line, process the line.
+        if (parts.length > 0) {
+          if (parts[0].equals("v")) {
+            // vertex
+            PVector tempv = new PVector(Float.valueOf(parts[1]).floatValue(),
+                                        Float.valueOf(parts[2]).floatValue(),
+                                        Float.valueOf(parts[3]).floatValue());
+            coords.add(tempv);
+            readv = true;
+          } else if (parts[0].equals("vn")) {
+            // normal
+            PVector tempn = new PVector(Float.valueOf(parts[1]).floatValue(),
+                                        Float.valueOf(parts[2]).floatValue(),
+                                        Float.valueOf(parts[3]).floatValue());
+            normals.add(tempn);
+            readvn = true;
+          } else if (parts[0].equals("vt")) {
+            // uv, inverting v to take into account Processing's inverted Y axis
+            // with respect to OpenGL.
+            PVector tempv = new PVector(Float.valueOf(parts[1]).floatValue(),
+                                        1 - Float.valueOf(parts[2]).
+                                        floatValue());
+            texcoords.add(tempv);
+            readvt = true;
+          } else if (parts[0].equals("o")) {
+            // Object name is ignored, for now.
+          } else if (parts[0].equals("mtllib")) {
+            if (parts[1] != null) {
+              String fn = parts[1];
+              if (fn.indexOf(File.separator) == -1 && !path.equals("")) {
+                // Relative file name, adding the base path.
+                fn = path + File.separator + fn;
+              }
+              BufferedReader mreader = parent.createReader(fn);
+              if (mreader != null) {
+                parseMTL(parent, fn, path, mreader, materials, mtlTable);
+                mreader.close();
+              }
+            }
+          } else if (parts[0].equals("g")) {
+            gname = 1 < parts.length ? parts[1] : "";
+          } else if (parts[0].equals("usemtl")) {
+            // Getting index of current active material (will be applied on
+            // all subsequent faces).
+            if (parts[1] != null) {
+              String mtlname = parts[1];
+              if (mtlTable.containsKey(mtlname)) {
+                Integer tempInt = mtlTable.get(mtlname);
+                mtlIdxCur = tempInt.intValue();
+              } else {
+                mtlIdxCur = -1;
+              }
+            }
+          } else if (parts[0].equals("f")) {
+            // Face setting
+            OBJFace face = new OBJFace();
+            face.matIdx = mtlIdxCur;
+            face.name = gname;
+
+            for (int i = 1; i < parts.length; i++) {
+              String seg = parts[i];
+
+              if (seg.indexOf("/") > 0) {
+                String[] forder = seg.split("/");
+
+                if (forder.length > 2) {
+                  // Getting vertex and texture and normal indexes.
+                  if (forder[0].length() > 0 && readv) {
+                    face.vertIdx.add(Integer.valueOf(forder[0]));
+                  }
+
+                  if (forder[1].length() > 0 && readvt) {
+                    face.texIdx.add(Integer.valueOf(forder[1]));
+                  }
+
+                  if (forder[2].length() > 0 && readvn) {
+                    face.normIdx.add(Integer.valueOf(forder[2]));
+                  }
+                } else if (forder.length > 1) {
+                  // Getting vertex and texture/normal indexes.
+                  if (forder[0].length() > 0 && readv) {
+                    face.vertIdx.add(Integer.valueOf(forder[0]));
+                  }
+
+                  if (forder[1].length() > 0) {
+                    if (readvt) {
+                      face.texIdx.add(Integer.valueOf(forder[1]));
+                    } else  if (readvn) {
+                      face.normIdx.add(Integer.valueOf(forder[1]));
+                    }
+
+                  }
+
+                } else if (forder.length > 0) {
+                  // Getting vertex index only.
+                  if (forder[0].length() > 0 && readv) {
+                    face.vertIdx.add(Integer.valueOf(forder[0]));
+                  }
+                }
+              } else {
+                // Getting vertex index only.
+                if (seg.length() > 0 && readv) {
+                  face.vertIdx.add(Integer.valueOf(seg));
+                }
+              }
+            }
+
+            faces.add(face);
+          }
+        }
+      }
+
+      if (materials.size() == 0) {
+        // No materials definition so far. Adding one default material.
+        OBJMaterial defMtl = new OBJMaterial();
+        materials.add(defMtl);
+      }
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+    /**
+     *
+     * @param parent
+     * @param mtlfn
+     * @param path
+     * @param reader
+     * @param materials
+     * @param materialsHash
+     */
+    static protected void parseMTL(PApplet parent, String mtlfn, String path,
+                                 BufferedReader reader,
+                                 ArrayList<OBJMaterial> materials,
+                                 Map<String, Integer> materialsHash) {
+    try {
+      String line;
+      OBJMaterial currentMtl = null;
+      while ((line = reader.readLine()) != null) {
+        // Parse the line
+        line = line.trim();
+        String parts[] = line.split("\\s+");
+        if (parts.length > 0) {
+          // Extract the material data.
+          if (parts[0].equals("newmtl")) {
+            // Starting new material.
+            String mtlname = parts[1];
+            currentMtl = addMaterial(mtlname, materials, materialsHash);
+          } else {
+            if (currentMtl == null) {
+              currentMtl = addMaterial("material" + materials.size(),
+                                       materials, materialsHash);
+            }
+            if (parts[0].equals("map_Kd") && parts.length > 1) {
+              // Loading texture map.
+              String texname = parts[1];
+              if (texname.indexOf(File.separator) == -1 && !path.equals("")) {
+                // Relative file name, adding the base path.
+                texname = path + File.separator + texname;
+              }
+
+              File file = new File(parent.dataPath(texname));
+              if (file.exists()) {
+                currentMtl.kdMap = parent.loadImage(texname);
+              } else {
+                System.err.println("The texture map \"" + texname + "\" " +
+                  "in the materials definition file \"" + mtlfn + "\" " +
+                  "is missing or inaccessible, make sure " +
+                  "the URL is valid or that the file has been " +
+                  "added to your sketch and is readable.");
+              }
+            } else if (parts[0].equals("Ka") && parts.length > 3) {
+              // The ambient color of the material
+              currentMtl.ka.x = Float.valueOf(parts[1]).floatValue();
+              currentMtl.ka.y = Float.valueOf(parts[2]).floatValue();
+              currentMtl.ka.z = Float.valueOf(parts[3]).floatValue();
+            } else if (parts[0].equals("Kd") && parts.length > 3) {
+              // The diffuse color of the material
+              currentMtl.kd.x = Float.valueOf(parts[1]).floatValue();
+              currentMtl.kd.y = Float.valueOf(parts[2]).floatValue();
+              currentMtl.kd.z = Float.valueOf(parts[3]).floatValue();
+            } else if (parts[0].equals("Ks") && parts.length > 3) {
+              // The specular color weighted by the specular coefficient
+              currentMtl.ks.x = Float.valueOf(parts[1]).floatValue();
+              currentMtl.ks.y = Float.valueOf(parts[2]).floatValue();
+              currentMtl.ks.z = Float.valueOf(parts[3]).floatValue();
+            } else if ((parts[0].equals("d") ||
+                        parts[0].equals("Tr")) && parts.length > 1) {
+              // Reading the alpha transparency.
+              currentMtl.d = Float.valueOf(parts[1]).floatValue();
+            } else if (parts[0].equals("Ns") && parts.length > 1) {
+              // The specular component of the Phong shading model
+              currentMtl.ns = Float.valueOf(parts[1]).floatValue();
+            }
+          }
+        }
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+    /**
+     *
+     * @param mtlname
+     * @param materials
+     * @param materialsHash
+     * @return
+     */
+    protected static OBJMaterial addMaterial(String mtlname,
+                                           ArrayList<OBJMaterial> materials,
+                                           Map<String, Integer> materialsHash) {
+    OBJMaterial currentMtl = new OBJMaterial(mtlname);
+    materialsHash.put(mtlname, Integer.valueOf(materials.size()));
+    materials.add(currentMtl);
+    return currentMtl;
+  }
+
+    /**
+     *
+     * @param color
+     * @return
+     */
+    protected static int rgbaValue(PVector color) {
+    return 0xFF000000 | ((int)(color.x * 255) << 16) |
+                        ((int)(color.y * 255) <<  8) |
+                         (int)(color.z * 255);
+  }
+
+    /**
+     *
+     * @param color
+     * @param alpha
+     * @return
+     */
+    protected static int rgbaValue(PVector color, float alpha) {
+    return ((int)(alpha * 255)   << 24) |
+           ((int)(color.x * 255) << 16) |
+           ((int)(color.y * 255) <<  8) |
+            (int)(color.z * 255);
+  }
+
+
+  // Stores a face from an OBJ file
+
+    /**
+     *
+     */
+  static protected class OBJFace {
+    ArrayList<Integer> vertIdx;
+    ArrayList<Integer> texIdx;
+    ArrayList<Integer> normIdx;
+    int matIdx;
+    String name;
+
+    OBJFace() {
+      vertIdx = new ArrayList<Integer>();
+      texIdx = new ArrayList<Integer>();
+      normIdx = new ArrayList<Integer>();
+      matIdx = -1;
+      name = "";
+    }
+  }
+
+    /**
+     *
+     * @param parent
+     * @param filename
+     * @return
+     */
+    static protected String getBasePath(PApplet parent, String filename) {
+    // Obtaining the path
+    File file = new File(parent.dataPath(filename));
+    if (!file.exists()) {
+      file = parent.sketchFile(filename);
+    }
+    String absolutePath = file.getAbsolutePath();
+    return absolutePath.substring(0,
+            absolutePath.lastIndexOf(File.separator));
+  }
+
+
+  // Stores a material defined in an MTL file.
+
+    /**
+     *
+     */
+  static protected class OBJMaterial {
+    String name;
+    PVector ka;
+    PVector kd;
+    PVector ks;
+    float d;
+    float ns;
+    PImage kdMap;
+
+    OBJMaterial() {
+      this("default");
+    }
+
+    OBJMaterial(String name) {
+      this.name = name;
+      ka = new PVector(0.5f, 0.5f, 0.5f);
+      kd = new PVector(0.5f, 0.5f, 0.5f);
+      ks = new PVector(0.5f, 0.5f, 0.5f);
+      d = 1.0f;
+      ns = 0.0f;
+      kdMap = null;
+    }
+  }
+}