diff --git a/README.md b/README.md index 110697c..33bdb8c 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,111 @@ CUDA Path Tracer ================ +![My best render.](img/elephant1001.png) + **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 3** -* (TODO) YOUR NAME HERE -* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab) +* Daniel Daley-Montgomery +* Tested on: MacBook Pro, OSX 10.12, i7 @ 2.3GHz, 16GB RAM, GT 750M 2048MB (Personal Machine) + + High-speed rasterization pipelines like OpenGL might be able to put a lot of images on the screen in short time, but when it comes to true physical realism, path tracing is king. Used by modern movie studios, path tracing models rays of light by tracing them in reverse from the camera eye to light sources, bouncing around the scene in the process. This allows for the capture of indirect light, as shown below. + +![PT.](https://www.scratchapixel.com/images/upload/shading-intro2/shad2-globalillum3.png?) + + The problem with path tracing is that, at its best, it's extrmely slow. This project will aim to accelerate a path tracing system by parallelizing over light rays on the GPU. At a high level, the program will look like this: +``` +//Generate rays +for each pixel in parallel { + new path (x,y) +} + +//Bounce around the scene +while (active paths exist) { + + //path collisions + for each path in parallel { + path.collide(scene) + + //shading + if (collision) { + path.color(collision) + if (isLight(collision) path.deactivate + path.redirect(collision, random variable) + } + + else path.deactivate +` } +} + +for each path in parallel { + screen.add(path.color) +} +``` + + +### Path Generation and Collision + + While writing *path.collide(scene)* is easy, this is the most performance-intensive part of my path tracer. The basic approach - + ``` + for each path in parallel { + for each primitive in parallel { + detect collision (path, primitive) + } + } + ``` +- is ghastly. With a 900x900 scene, 2,000 primitives, and 12 bounces I could have as many as *19.4 million* collision tests to do in one iteration in the worst case. Fortunately, we've got a few optimizations to speed things up: + +![](img/stream.png) + +###### Stream Compaction + + First, that worst case should never have to happen when we can stop tracing paths that hit lights or fly into space. But we dont want to launch kernels that check *if (path is dead) return;*, because if a warp of 31 dead paths and 1 active path is launched, it will take just as long as 32 active paths... the last bounce will be as costly as the first! + + Instead, I specifically separated active paths from inactive ones using *stream compaction*, provided by the [thrust](https://developer.nvidia.com/thrust) library, and was thus able to only launch as many threads as was necessary to cover the active ones. + +###### Caching + + One easy way to save a round of intersections tests is caching the first bounce. Since we're casting them through pixels, they'll always hit the same location. I accurately simulated the first bounce, saved it to device memory, then was able to start on the second bounce every subsequent frame. + + When I decided I wanted anti aliasing, this became an issue. A jittered antialiasing solution would change my first bounce, rendering my cache incorrect. To get the best of both worlds, I jittered and re-filled my cache every *x* frames. This means that after the first bounce my caching is *1/x*% less effective, but effective nonetheless. + +###### Primitive Reduction + + While 5 or 6 boxes or spheres can be practically nigligible in terms of compute time, even my <1000 triangle elephant blew up iteration time. As the first step to cutting down this nested path-geometry relationship, i implemented a bounding box for my mesh imports. If a ray didn't hit the bounding box (or already had a closer hit), it ignored the rest of the mesh as well. + + While this was extremely helpful, it won't get my CUDA path tracer to any competitive speeds. Instead, my next improvement will be to the entire scene: A [bounding volume heirarchy](https://en.wikipedia.org/wiki/Octree) accesible on the GPU. Like [light clustering](https://github.com/illDivino/Project5-WebGL-Clustered-Deferred-Forward-Plus), I predict this will have a massive impact. + +#### Shading and Redirection + + Once we have a collision, we can get to the best part. At the shading stage, we try our best to represent physical meterials and their light reflection/absorbtion/transmission/emission tendencies. In my project, I included the following three material properties, which could be blended together by assigning the likelihood that a given collision would chose any lighting model. Pictured as well are the [BRDFs](https://en.wikipedia.org/wiki/Bidirectional_reflectance_distribution_function) used to represent the new direction of an incident ray: + +|Perfect Difusse|Perfect Specular|Fresnel Refractive| +|-----|-----|-----| +|||| +|||| + + Because different materials have different amounts of work involved in processing (and also different likelihoods of deactivating a ray on this iteration or the next), we can prevent even more divergence if we sort rays by the material they hit. + + The level of randomness in choosing in a direction necessarily produces noise in the output image. While it's impossible to sample the continuous hemisphere around a normal, we can get a good picture given enough random samples: + +|Iterations|Result| +|-----|-----| +3|![](img/Cornell_3.png)| +10|![](img/Cornell_10.png)| +25|![](img/Cornell_25.png)| +50|![](img/Cornell_50.png)| +200|![](img/Cornell_200.png)| +1000|![](img/Cornell_1000.png)| + +This is the '[Monte Carlo](https://en.wikipedia.org/wiki/Monte_Carlo_method)' in Monte Carlo Path Tracing. Various techniques, like bidirectional, direct, and importance sampling can help accelerate convergence to the final image. These methods have unfortunately not yet been implemented in my project. + +##### Performance -### (TODO: Your README) +The following stats were captured with the test image at the top of this wiki. Notably, his image had a wall behind the camera preventing rays from being deactivated due to no collision. -*DO NOT* leave the README to the last minute! It is a crucial part of the -project, and we will not be able to grade you without a good README. + + + With any mesh in the scene, the far-and-away most important improvement is bounding boxes. For paths who do not intersect the mesh, this reduced intersection tests by 95%, especially influential when more than %90 of my GPU time was spent in generating collisions. + + Surprisingly, the materials sorting was influential even though my materials were rather simple. My guess is that the important separation was between those rays that hit the mesh (gold material) and those that didn't, since those that did would be guarunteed to hit the mesh's bounding box on the next collision generation. diff --git a/img/12Bounce.png b/img/12Bounce.png new file mode 100644 index 0000000..ebdbf7f Binary files /dev/null and b/img/12Bounce.png differ diff --git a/img/5Bounce.png b/img/5Bounce.png new file mode 100644 index 0000000..1f3eb32 Binary files /dev/null and b/img/5Bounce.png differ diff --git a/img/Cornell_10.png b/img/Cornell_10.png new file mode 100644 index 0000000..27e564f Binary files /dev/null and b/img/Cornell_10.png differ diff --git a/img/Cornell_1000.png b/img/Cornell_1000.png new file mode 100644 index 0000000..c2e6f9d Binary files /dev/null and b/img/Cornell_1000.png differ diff --git a/img/Cornell_200.png b/img/Cornell_200.png new file mode 100644 index 0000000..5891d4f Binary files /dev/null and b/img/Cornell_200.png differ diff --git a/img/Cornell_25.png b/img/Cornell_25.png new file mode 100644 index 0000000..ad5d2c1 Binary files /dev/null and b/img/Cornell_25.png differ diff --git a/img/Cornell_3.png b/img/Cornell_3.png new file mode 100644 index 0000000..69ff148 Binary files /dev/null and b/img/Cornell_3.png differ diff --git a/img/Cornell_50.png b/img/Cornell_50.png new file mode 100644 index 0000000..aeb586b Binary files /dev/null and b/img/Cornell_50.png differ diff --git a/img/DeerAndBall50.png b/img/DeerAndBall50.png new file mode 100644 index 0000000..468d17a Binary files /dev/null and b/img/DeerAndBall50.png differ diff --git a/img/Diff.png b/img/Diff.png new file mode 100644 index 0000000..9e5c21c Binary files /dev/null and b/img/Diff.png differ diff --git a/img/EarlyGlass.png b/img/EarlyGlass.png new file mode 100644 index 0000000..41ec192 Binary files /dev/null and b/img/EarlyGlass.png differ diff --git a/img/Normals.png b/img/Normals.png new file mode 100644 index 0000000..9661cad Binary files /dev/null and b/img/Normals.png differ diff --git a/img/Refr.png b/img/Refr.png new file mode 100644 index 0000000..729845c Binary files /dev/null and b/img/Refr.png differ diff --git a/img/Screen Shot 2017-12-09 at 5.45.24 PM.png b/img/Screen Shot 2017-12-09 at 5.45.24 PM.png new file mode 100644 index 0000000..991e88b Binary files /dev/null and b/img/Screen Shot 2017-12-09 at 5.45.24 PM.png differ diff --git a/img/Screen Shot 2017-12-09 at 5.45.47 PM.png b/img/Screen Shot 2017-12-09 at 5.45.47 PM.png new file mode 100644 index 0000000..f42dd1a Binary files /dev/null and b/img/Screen Shot 2017-12-09 at 5.45.47 PM.png differ diff --git a/img/Screen Shot 2017-12-09 at 5.46.01 PM.png b/img/Screen Shot 2017-12-09 at 5.46.01 PM.png new file mode 100644 index 0000000..0e8c738 Binary files /dev/null and b/img/Screen Shot 2017-12-09 at 5.46.01 PM.png differ diff --git a/img/Spec.png b/img/Spec.png new file mode 100644 index 0000000..ed69287 Binary files /dev/null and b/img/Spec.png differ diff --git a/img/cornell.2017-11-10_04-26-44z.181samp.png b/img/cornell.2017-11-10_04-26-44z.181samp.png new file mode 100644 index 0000000..dd51121 Binary files /dev/null and b/img/cornell.2017-11-10_04-26-44z.181samp.png differ diff --git a/img/elephant1001.png b/img/elephant1001.png new file mode 100644 index 0000000..4fac01d Binary files /dev/null and b/img/elephant1001.png differ diff --git a/img/stream.png b/img/stream.png new file mode 100644 index 0000000..aa46a52 Binary files /dev/null and b/img/stream.png differ diff --git a/scenes/Wallpaper.txt b/scenes/Wallpaper.txt new file mode 100644 index 0000000..1521f0d --- /dev/null +++ b/scenes/Wallpaper.txt @@ -0,0 +1,172 @@ +// Emissive material (light) +MATERIAL 0 +RGB 1 1 1 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 1 + +// Diffuse white +MATERIAL 1 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// Diffuse red +MATERIAL 2 +RGB .85 .35 .35 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// Diffuse blue +MATERIAL 3 +RGB .35 .35 .85 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// Gold +MATERIAL 4 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB .35 .85 .35 +REFL 1.0 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// Gold +MATERIAL 5 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB .35 .85 .35 +REFL 0.2 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// refractive blue +MATERIAL 6 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB .35 .85 .35 +REFL 0.0 +REFR 1.0 +REFRIOR 1.5 +EMITTANCE 0 + +// Diffuse blue +MATERIAL 7 +RGB .35 .35 .85 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// Camera +CAMERA +RES 2880 1800 +FOVY 45 +ITERATIONS 5000 +DEPTH 8 +FILE cornell +EYE 0.0 5 1.5 +LOOKAT 0 5 0 +UP 0 1 0 + + +// Ceiling light +OBJECT 0 +cube +material 0 +TRANS 0 10 0 +ROTAT 0 0 0 +SCALE 10 .03 10 + +// Floor +OBJECT 1 +cube +material 1 +TRANS 0 0 0 +ROTAT 0 0 0 +SCALE 10 .01 10 + +// Ceiling +OBJECT 2 +cube +material 1 +TRANS 0 10 0 +ROTAT 0 0 90 +SCALE .01 10 10 + +// Back wall +OBJECT 3 +cube +material 1 +TRANS 0 5 -5 +ROTAT 0 90 0 +SCALE .1 10 10 + + +// Left wall +OBJECT 4 +cube +material 2 +TRANS -5 5 0 +ROTAT 0 0 0 +SCALE .01 10 10 + +// Right wall +OBJECT 5 +cube +material 3 +TRANS 5 5 0 +ROTAT 0 0 0 +SCALE .01 10 10 + +// Sphere +OBJECT 6 +sphere +material 4 +TRANS 0 7.5 -4 +ROTAT 0 0 0 +SCALE 3 3 3 + +// Sphere +OBJECT 7 +sphere +material 5 +TRANS 0 5 -4 +ROTAT 0 0 0 +SCALE 3 3 3 + +// Sphere +OBJECT 8 +sphere +material 6 +TRANS 0 2.5 -4 +ROTAT 0 0 0 +SCALE 3 3 3 + +//Front wall +OBJECT 9 +cube +material 1 +TRANS 0 5 5 +ROTAT 0 90 0 +SCALE .1 100 100 \ No newline at end of file diff --git a/scenes/cornell.txt b/scenes/cornell.txt index 83ff820..7afb4f5 100644 --- a/scenes/cornell.txt +++ b/scenes/cornell.txt @@ -6,13 +6,13 @@ SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 -EMITTANCE 5 +EMITTANCE 3.75 // Diffuse white MATERIAL 1 RGB .98 .98 .98 SPECEX 0 -SPECRGB 0 0 0 +SPECRGB 1 1 1 REFL 0 REFR 0 REFRIOR 0 @@ -22,7 +22,7 @@ EMITTANCE 0 MATERIAL 2 RGB .85 .35 .35 SPECEX 0 -SPECRGB 0 0 0 +SPECRGB 1 1 1 REFL 0 REFR 0 REFRIOR 0 @@ -32,30 +32,50 @@ EMITTANCE 0 MATERIAL 3 RGB .35 .85 .35 SPECEX 0 -SPECRGB 0 0 0 +SPECRGB 1 1 1 REFL 0 REFR 0 REFRIOR 0 EMITTANCE 0 -// Specular white +// Gold MATERIAL 4 -RGB .98 .98 .98 +RGB 1 1 1 SPECEX 0 -SPECRGB .98 .98 .98 +SPECRGB 0.8 0.7 0.43 REFL 1 REFR 0 REFRIOR 0 EMITTANCE 0 +// refractive blue +MATERIAL 5 +RGB 0.75 0.75 1 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0.0 +REFR 1.0 +REFRIOR 1.33 +EMITTANCE 0 + +// black +MATERIAL 6 +RGB 0.1 0.1 0.1 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0.3 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + // Camera CAMERA -RES 800 800 +RES 900 900 FOVY 45 ITERATIONS 5000 -DEPTH 8 +DEPTH 7 FILE cornell -EYE 0.0 5 10.5 +EYE 0.0 5 4.8 LOOKAT 0 5 0 UP 0 1 0 @@ -64,9 +84,9 @@ UP 0 1 0 OBJECT 0 cube material 0 -TRANS 0 10 0 +TRANS 0 9.8 -2 ROTAT 0 0 0 -SCALE 3 .3 3 +SCALE 4 .1 4 // Floor OBJECT 1 @@ -76,24 +96,17 @@ TRANS 0 0 0 ROTAT 0 0 0 SCALE 10 .01 10 -// Ceiling -OBJECT 2 -cube -material 1 -TRANS 0 10 0 -ROTAT 0 0 90 -SCALE .01 10 10 - // Back wall -OBJECT 3 +OBJECT 2 cube material 1 TRANS 0 5 -5 ROTAT 0 90 0 -SCALE .01 10 10 +SCALE .1 10 10 + // Left wall -OBJECT 4 +OBJECT 3 cube material 2 TRANS -5 5 0 @@ -101,17 +114,48 @@ ROTAT 0 0 0 SCALE .01 10 10 // Right wall -OBJECT 5 +OBJECT 4 cube material 3 TRANS 5 5 0 ROTAT 0 0 0 SCALE .01 10 10 -// Sphere +//Front wall +OBJECT 5 +cube +material 1 +TRANS 0 5 6 +ROTAT 0 90 0 +SCALE 0.01 100 100 + +//Sphere 2 OBJECT 6 sphere -material 4 -TRANS -1 4 -1 +material 5 +TRANS -1.2 3.6 -1 ROTAT 0 0 0 -SCALE 3 3 3 +SCALE 2.5 2.5 2.5 + +// Ceiling +OBJECT 7 +cube +material 1 +TRANS 0 10 0 +ROTAT 0 0 0 +SCALE 10 0.1 10 + +OBJECT 8 +cube +material 1 +TRANS 0 1 -1 +ROTAT 0 0 0 +SCALE 7 2 4 + +// Sphere +OBJECT 9 +C:\Users\Alex\Documents\565\Project3-CUDA-Path-Tracer\scenes\elephav.obj +material 4 +TRANS 1.7 2 -1.8 +ROTAT 0 20 0 +SCALE .0035 .0035 .0035 \ No newline at end of file diff --git a/scenes/outside.txt b/scenes/outside.txt new file mode 100644 index 0000000..6a27e13 --- /dev/null +++ b/scenes/outside.txt @@ -0,0 +1,125 @@ +// Emissive material (light) +MATERIAL 0 +RGB 1 1 1 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 2.5 + +// Diffuse gray +MATERIAL 1 +RGB .8 .8 .8 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// Diffuse orange +MATERIAL 2 +RGB .9 .4 .5 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0.1 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// chrome +MATERIAL 3 +RGB 1 1 1 +SPECEX 0 +SPECRGB .95 .95 .95 +REFL 1 +REFR 0 +REFRIOR 0 +EMITTANCE 0 + +// green +MATERIAL 4 +RGB .6 1 .6 +SPECEX 0 +SPECRGB .95 .95 .95 +REFL 1 +REFR 1 +REFRIOR 1.55 +EMITTANCE 0 + +// Camera +CAMERA +RES 900 900 +FOVY 45 +ITERATIONS 5000 +DEPTH 16 +FILE cornell +EYE 0.0 1 4 +LOOKAT 0 3 0 +UP 0 1 0 + + +// Ceiling light +OBJECT 0 +sphere +material 0 +TRANS 0 23 0 +ROTAT 0 0 0 +SCALE 15 15 15 + +// Floor +OBJECT 1 +cube +material 1 +TRANS 0 -0.5 0 +ROTAT 0 0 0 +SCALE 100 1 100 + +//Sphere 2 +OBJECT 2 +sphere +material 2 +TRANS 2 2 -2 +ROTAT 0 0 0 +SCALE 4 4 4 + +//Sphere 3 +OBJECT 3 +sphere +material 1 +TRANS 0 2 -2 +ROTAT 0 0 0 +SCALE 100 100 100 + +//Sphere 2 +OBJECT 4 +sphere +material 2 +TRANS 2 4.75 -2 +ROTAT 0 0 0 +SCALE 1.5 1.5 1.5 + +//Sphere 2 +OBJECT 5 +sphere +material 2 +TRANS 2 5.78 -2 +ROTAT 0 0 0 +SCALE .56 .56 .56 + +//Sphere 2 +OBJECT 6 +sphere +material 3 +TRANS -2 2.25 -4 +ROTAT 0 0 0 +SCALE 4.5 4.5 4.5 + +//Sphere 2 +OBJECT 7 +sphere +material 3 +TRANS 0 1 1 +ROTAT 0 0 0 +SCALE 2 2 2 diff --git a/scenes/sphere.txt b/scenes/sphere.txt index a74b545..348cc9e 100644 --- a/scenes/sphere.txt +++ b/scenes/sphere.txt @@ -1,6 +1,6 @@ // Emissive material (light) MATERIAL 0 -RGB 1 1 1 +RGB 1 0 0 SPECEX 0 SPECRGB 0 0 0 REFL 0 diff --git a/src/interactions.h b/src/interactions.h index 5ce3628..0d720a9 100644 --- a/src/interactions.h +++ b/src/interactions.h @@ -1,7 +1,7 @@ #pragma once #include "intersections.h" - +#define DISPLAY_NORMALS 0 // CHECKITOUT /** * Computes a cosine-weighted random direction in a hemisphere. @@ -73,7 +73,65 @@ void scatterRay( glm::vec3 normal, const Material &m, thrust::default_random_engine &rng) { - // TODO: implement this. - // A basic implementation of pure-diffuse shading will just call the - // calculateRandomDirectionInHemisphere defined above. + + +#if DISPLAY_NORMALS + pathSegment.remainingBounces = 0; + pathSegment.color = abs(normal); +#else + + pathSegment.ray.origin = intersect; + thrust::uniform_real_distribution u01; + float rand = u01(rng); + + //refraction + if (m.hasRefractive) { + + float coeff = 0; + float cosTheta = -glm::dot(pathSegment.ray.direction, normal); + bool incomingFromOutside = (pathSegment.insideT == 0); + + //get indices of refraction and r0 for Schlick's + float n1 = incomingFromOutside ? 1 : m.indexOfRefraction; + float n2 = incomingFromOutside ? m.indexOfRefraction : 1; + float n = n1 / n2; + float R0 = (n1 - n2) / (n1 + n2); + R0 *= R0; + + if (n1 > n2) { + float sinT2 = n*n*(1.0 - cosTheta*cosTheta); + cosTheta = sqrt(1.0 - sinT2); + // Total internal reflection + if (sinT2 > 1.0f) + coeff = 1.0f; + } + + if (coeff == 0.0f) { + float x = 1.0 - cosTheta; + coeff = R0 + (1.0 - R0)*x*x*x*x*x; + } + + if (rand > coeff) { + pathSegment.ray.origin += 0.01f * pathSegment.ray.direction; + pathSegment.ray.direction = glm::refract(pathSegment.ray.direction, normal, n); + if (!incomingFromOutside) { + glm::vec3 c_absorb = (glm::vec3(1.1f) - m.color); + glm::vec3 absorb = glm::clamp(glm::exp(-c_absorb * 0.33f * pathSegment.insideT), glm::vec3(0.0f), glm::vec3(1.0f)); + pathSegment.color *= m.color; + } + } else { + pathSegment.ray.direction = glm::reflect(pathSegment.ray.direction, normal); + pathSegment.color *= m.specular.color; + } + + } + //diffuse + else if (rand > m.hasReflective) { + pathSegment.color *= m.color; + pathSegment.ray.direction = calculateRandomDirectionInHemisphere(normal, rng); + } else { + pathSegment.ray.direction = glm::reflect(pathSegment.ray.direction, normal); + pathSegment.color *= m.specular.color; + } +#endif } diff --git a/src/intersections.h b/src/intersections.h index 6f23872..d857834 100644 --- a/src/intersections.h +++ b/src/intersections.h @@ -89,6 +89,17 @@ __host__ __device__ float boxIntersectionTest(Geom box, Ray r, return -1; } +__device__ float triangleIntersectionTest(Geom triangle, Ray r, glm::vec3 &intersectionPoint, glm::vec3 &normal, bool &outside) { + + glm::vec3 result; + glm::intersectRayTriangle(r.origin, r.direction, triangle.vertices[0], triangle.vertices[1], triangle.vertices[2], result); + + intersectionPoint = result.z * r.direction + r.origin; + outside = glm::dot(r.direction, triangle.normal) < 0; + normal = outside ? triangle.normal : - triangle.normal; + return result.z; +} + // CHECKITOUT /** * Test intersection between a ray and a transformed sphere. Untransformed, diff --git a/src/main.cpp b/src/main.cpp index fe8e85e..f90168b 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,6 +1,7 @@ #include "main.h" #include "preview.h" #include +#include static std::string startTimeString; @@ -22,6 +23,7 @@ glm::vec3 ogLookAt; // for recentering the camera Scene *scene; RenderState *renderState; int iteration; +double total; int width; int height; @@ -134,7 +136,13 @@ void runCuda() { // execute the kernel int frame = 0; - pathtrace(pbo_dptr, frame, iteration); + clock_t begin = clock(); + pathtrace(pbo_dptr, frame, iteration); + clock_t end = clock(); + + total += (end - begin) * 1000.0f / CLOCKS_PER_SEC; + std::cout << iteration << ": " << total / (CLOCKS_PER_SEC) << std::endl; + total = 0; // unmap buffer object cudaGLUnmapBufferObject(pbo); diff --git a/src/pathtrace.cu b/src/pathtrace.cu index c1ec122..a0eea8d 100644 --- a/src/pathtrace.cu +++ b/src/pathtrace.cu @@ -4,6 +4,8 @@ #include #include #include +#include +#include #include "sceneStructs.h" #include "scene.h" @@ -14,7 +16,9 @@ #include "intersections.h" #include "interactions.h" -#define ERRORCHECK 1 +#define ERRORCHECK 0 +#define SORT_MATERIALS 1 +#define CACHE_PATHS 1 #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__) @@ -71,8 +75,14 @@ static Scene * hst_scene = NULL; static glm::vec3 * dev_image = NULL; static Geom * dev_geoms = NULL; static Material * dev_materials = NULL; +static PathSegment* dev_cached_paths = NULL; static PathSegment * dev_paths = NULL; +static ShadeableIntersection * dev_cached_intersections = NULL; static ShadeableIntersection * dev_intersections = NULL; + +thrust::device_ptr dev_thrust_paths; +thrust::device_ptr dev_thrust_intersections; + // TODO: static variables for device memory, any extra info you need, etc // ... @@ -85,16 +95,21 @@ void pathtraceInit(Scene *scene) { cudaMemset(dev_image, 0, pixelcount * sizeof(glm::vec3)); cudaMalloc(&dev_paths, pixelcount * sizeof(PathSegment)); + cudaMalloc(&dev_cached_paths, pixelcount * sizeof(PathSegment)); cudaMalloc(&dev_geoms, scene->geoms.size() * sizeof(Geom)); cudaMemcpy(dev_geoms, scene->geoms.data(), scene->geoms.size() * sizeof(Geom), cudaMemcpyHostToDevice); cudaMalloc(&dev_materials, scene->materials.size() * sizeof(Material)); cudaMemcpy(dev_materials, scene->materials.data(), scene->materials.size() * sizeof(Material), cudaMemcpyHostToDevice); - + + cudaMalloc(&dev_cached_intersections, pixelcount * sizeof(ShadeableIntersection)); cudaMalloc(&dev_intersections, pixelcount * sizeof(ShadeableIntersection)); cudaMemset(dev_intersections, 0, pixelcount * sizeof(ShadeableIntersection)); + dev_thrust_paths = thrust::device_ptr(dev_paths); + dev_thrust_intersections = thrust::device_ptr(dev_intersections); + // TODO: initialize any extra device memeory you need checkCUDAError("pathtraceInit"); @@ -129,12 +144,15 @@ __global__ void generateRayFromCamera(Camera cam, int iter, int traceDepth, Path PathSegment & segment = pathSegments[index]; segment.ray.origin = cam.position; - segment.color = glm::vec3(1.0f, 1.0f, 1.0f); + segment.color = glm::vec3(1.0f, 1.0f, 1.0f); + + thrust::default_random_engine rng = makeSeededRandomEngine(iter, index, 0); + thrust::uniform_real_distribution u01(0, 1); // TODO: implement antialiasing by jittering the ray segment.ray.direction = glm::normalize(cam.view - - cam.right * cam.pixelLength.x * ((float)x - (float)cam.resolution.x * 0.5f) - - cam.up * cam.pixelLength.y * ((float)y - (float)cam.resolution.y * 0.5f) + - cam.right * cam.pixelLength.x * ((float)x + u01(rng) - (float)cam.resolution.x * 0.5f) + - cam.up * cam.pixelLength.y * ((float)y + u01(rng) - (float)cam.resolution.y * 0.5f) ); segment.pixelIndex = index; @@ -166,7 +184,7 @@ __global__ void computeIntersections( glm::vec3 normal; float t_min = FLT_MAX; int hit_geom_index = -1; - bool outside = true; + bool isOutside = true; glm::vec3 tmp_intersect; glm::vec3 tmp_normal; @@ -175,6 +193,7 @@ __global__ void computeIntersections( for (int i = 0; i < geoms_size; i++) { + bool outside; Geom & geom = geoms[i]; if (geom.type == CUBE) @@ -185,6 +204,19 @@ __global__ void computeIntersections( { t = sphereIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside); } + else if (geom.type == TRIANGLE) { + t = triangleIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside); + } + else if (geom.type = BB) { + t = boxIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside); + if (t <= 0.0 || t > t_min) { + i += geom.numTris; + //hit_geom_index = -1; + //break; + } + continue; + } + // TODO: add more intersection tests here... triangle? metaball? CSG? // Compute the minimum t from the intersection tests to determine what @@ -195,19 +227,24 @@ __global__ void computeIntersections( hit_geom_index = i; intersect_point = tmp_intersect; normal = tmp_normal; + isOutside = outside; } } - + if (hit_geom_index == -1) { intersections[path_index].t = -1.0f; + pathSegments[path_index].remainingBounces = 0; } else { //The ray hits something + //pathSegment.remainingBounces--; intersections[path_index].t = t_min; + intersections[path_index].point = intersect_point; intersections[path_index].materialId = geoms[hit_geom_index].materialid; intersections[path_index].surfaceNormal = normal; + pathSegments[path_index].insideT = isOutside ? 0.0f : t_min; } } } @@ -221,48 +258,53 @@ __global__ void computeIntersections( // Note that this shader does NOT do a BSDF evaluation! // Your shaders should handle that - this can allow techniques such as // bump mapping. -__global__ void shadeFakeMaterial ( - int iter - , int num_paths +__global__ void shadeFakeMaterial( + int iter + , int num_paths , ShadeableIntersection * shadeableIntersections , PathSegment * pathSegments , Material * materials - ) + , glm::vec3 *image +) { - int idx = blockIdx.x * blockDim.x + threadIdx.x; - if (idx < num_paths) - { - ShadeableIntersection intersection = shadeableIntersections[idx]; - if (intersection.t > 0.0f) { // if the intersection exists... - // Set up the RNG - // LOOK: this is how you use thrust's RNG! Please look at - // makeSeededRandomEngine as well. - thrust::default_random_engine rng = makeSeededRandomEngine(iter, idx, 0); - thrust::uniform_real_distribution u01(0, 1); - - Material material = materials[intersection.materialId]; - glm::vec3 materialColor = material.color; - - // If the material indicates that the object was a light, "light" the ray - if (material.emittance > 0.0f) { - pathSegments[idx].color *= (materialColor * material.emittance); - } - // Otherwise, do some pseudo-lighting computation. This is actually more - // like what you would expect from shading in a rasterizer like OpenGL. - // TODO: replace this! you should be able to start with basically a one-liner - else { - float lightTerm = glm::dot(intersection.surfaceNormal, glm::vec3(0.0f, 1.0f, 0.0f)); - pathSegments[idx].color *= (materialColor * lightTerm) * 0.3f + ((1.0f - intersection.t * 0.02f) * materialColor) * 0.7f; - pathSegments[idx].color *= u01(rng); // apply some noise because why not - } - // If there was no intersection, color the ray black. - // Lots of renderers use 4 channel color, RGBA, where A = alpha, often - // used for opacity, in which case they can indicate "no opacity". - // This can be useful for post-processing and image compositing. - } else { - pathSegments[idx].color = glm::vec3(0.0f); - } - } + int idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx < num_paths) + { + ShadeableIntersection intersection = shadeableIntersections[idx]; + if (intersection.t > 0.0f) { // if the intersection exists... + // Set up the RNG + // LOOK: this is how you use thrust's RNG! Please look at + // makeSeededRandomEngine as well. + thrust::default_random_engine rng = makeSeededRandomEngine(iter, idx, 0); + thrust::uniform_real_distribution u01(0, 1); + + Material material = materials[intersection.materialId]; + glm::vec3 materialColor = material.color; + + // If the material indicates that the object was a light, "light" the ray + if (material.emittance > 0.0f) { + image[pathSegments[idx].pixelIndex] += pathSegments[idx].color * (materialColor * material.emittance); + pathSegments[idx].remainingBounces = 0; + } + // Otherwise, color and bounce + else { + scatterRay(pathSegments[idx], intersection.point, intersection.surfaceNormal, material, rng); +#if DISPLAY_NORMALS + image[pathSegments[idx].pixelIndex] += pathSegments[idx].color; +#endif + pathSegments[idx].remainingBounces--; + } + // If there was no intersection, color the ray black. + // Lots of renderers use 4 channel color, RGBA, where A = alpha, often + // used for opacity, in which case they can indicate "no opacity". + // This can be useful for post-processing and image compositing. + } + else { + //image[pathSegments[idx].pixelIndex] += glm::vec3(0.0f); + //pathSegments[idx].color = glm::vec3(0.0f); + pathSegments[idx].remainingBounces = 0; + } + } } // Add the current iteration's output to the overall image @@ -277,117 +319,112 @@ __global__ void finalGather(int nPaths, glm::vec3 * image, PathSegment * iterati } } +//from https://thrust.github.io/doc/group__stream__compaction.html#ga307d7f64566909172a3f9e16b7e2ad53 +struct path_complete { + __host__ __device__ bool operator()(PathSegment p) { + return p.remainingBounces <= 0; + } +}; + +//from http://www.sgi.com/tech/stl/StrictWeakOrdering.html and the above link +struct matComparator +{ + __host__ __device__ bool operator()(ShadeableIntersection &isThis, ShadeableIntersection &lessThanThis) + { + return isThis.materialId < lessThanThis.materialId; + } +}; + /** * Wrapper for the __global__ call that sets up the kernel calls and does a ton * of memory management */ void pathtrace(uchar4 *pbo, int frame, int iter) { - const int traceDepth = hst_scene->state.traceDepth; - const Camera &cam = hst_scene->state.camera; - const int pixelcount = cam.resolution.x * cam.resolution.y; + const int traceDepth = hst_scene->state.traceDepth; + const Camera &cam = hst_scene->state.camera; + const int pixelcount = cam.resolution.x * cam.resolution.y; // 2D block for generating ray from camera - const dim3 blockSize2d(8, 8); - const dim3 blocksPerGrid2d( - (cam.resolution.x + blockSize2d.x - 1) / blockSize2d.x, - (cam.resolution.y + blockSize2d.y - 1) / blockSize2d.y); + const dim3 blockSize2d(8, 8); + const dim3 blocksPerGrid2d( + (cam.resolution.x + blockSize2d.x - 1) / blockSize2d.x, + (cam.resolution.y + blockSize2d.y - 1) / blockSize2d.y); // 1D block for path tracing const int blockSize1d = 128; + dim3 numBlocksPixels = (pixelcount + blockSize1d - 1) / blockSize1d; + + //perform first bounce OR load cached first bounce +#if CACHE_PATHS + //store the initial paths and intersections, which will remain constant until camera moves (at which point iter == 0) + //currently jitters rays every 25 passes for antialiasing + if (iter % 25 == 1) { + generateRayFromCamera << > > (cam, iter, traceDepth, dev_cached_paths); + computeIntersections << > > (0, pixelcount, dev_cached_paths, dev_geoms, + hst_scene->geoms.size(), dev_cached_intersections); + cudaDeviceSynchronize(); + } + cudaMemcpy(dev_paths, dev_cached_paths, pixelcount * sizeof(PathSegment), cudaMemcpyDefault); + cudaMemcpy(dev_intersections, dev_cached_intersections, pixelcount * sizeof(ShadeableIntersection), cudaMemcpyDefault); +#else + generateRayFromCamera <<>>(cam, iter, traceDepth, dev_paths); + computeIntersections << > > ( + 0 + , pixelcount + , dev_paths + , dev_geoms + , hst_scene->geoms.size() + , dev_intersections + ); +#endif + checkCUDAError("First Bounce"); - /////////////////////////////////////////////////////////////////////////// - - // Recap: - // * Initialize array of path rays (using rays that come out of the camera) - // * You can pass the Camera object to that kernel. - // * Each path ray must carry at minimum a (ray, color) pair, - // * where color starts as the multiplicative identity, white = (1, 1, 1). - // * This has already been done for you. - // * For each depth: - // * Compute an intersection in the scene for each path ray. - // A very naive version of this has been implemented for you, but feel - // free to add more primitives and/or a better algorithm. - // Currently, intersection distance is recorded as a parametric distance, - // t, or a "distance along the ray." t = -1.0 indicates no intersection. - // * Color is attenuated (multiplied) by reflections off of any object - // * TODO: Stream compact away all of the terminated paths. - // You may use either your implementation or `thrust::remove_if` or its - // cousins. - // * Note that you can't really use a 2D kernel launch any more - switch - // to 1D. - // * TODO: Shade the rays that intersected something or didn't bottom out. - // That is, color the ray by performing a color computation according - // to the shader, then generate a new ray to continue the ray path. - // We recommend just updating the ray's PathSegment in place. - // Note that this step may come before or after stream compaction, - // since some shaders you write may also cause a path to terminate. - // * Finally, add this iteration's results to the image. This has been done - // for you. - - // TODO: perform one iteration of path tracing - - generateRayFromCamera <<>>(cam, iter, traceDepth, dev_paths); - checkCUDAError("generate camera ray"); - - int depth = 0; + int depth = 1; PathSegment* dev_path_end = dev_paths + pixelcount; int num_paths = dev_path_end - dev_paths; + bool iterationComplete = false; + dim3 numblocksPathSegmentTracing = numBlocksPixels; - // --- PathSegment Tracing Stage --- - // Shoot ray into scene, bounce between objects, push shading chunks - - bool iterationComplete = false; while (!iterationComplete) { - // clean shading chunks - cudaMemset(dev_intersections, 0, pixelcount * sizeof(ShadeableIntersection)); +#if SORT_MATERIALS + thrust::sort_by_key(dev_thrust_intersections, dev_thrust_intersections + num_paths, dev_thrust_paths, matComparator()); + checkCUDAError("Failed to Sort Material IDs"); +#endif - // tracing - dim3 numblocksPathSegmentTracing = (num_paths + blockSize1d - 1) / blockSize1d; - computeIntersections <<>> ( - depth - , num_paths - , dev_paths - , dev_geoms - , hst_scene->geoms.size() - , dev_intersections - ); - checkCUDAError("trace one bounce"); - cudaDeviceSynchronize(); - depth++; - - - // TODO: - // --- Shading Stage --- - // Shade path segments based on intersections and generate new rays by - // evaluating the BSDF. - // Start off with just a big kernel that handles all the different - // materials you have in the scenefile. - // TODO: compare between directly shading the path segments and shading - // path segments that have been reshuffled to be contiguous in memory. - - shadeFakeMaterial<<>> ( - iter, - num_paths, - dev_intersections, - dev_paths, - dev_materials - ); - iterationComplete = true; // TODO: should be based off stream compaction results. + //SHADE INTERSECTIONS, SCATTER RAYS + shadeFakeMaterial << > > (iter, num_paths, dev_intersections, dev_paths, + dev_materials, dev_image); + + //STREAM COMPACT TO REMOVE USELESS PATHS + PathSegment* new_dev_paths_end = thrust::remove_if(thrust::device, dev_paths, dev_paths + num_paths, path_complete());//-- 2: cull those paths that don't need any more shading + num_paths = new_dev_paths_end - dev_paths; + + //END THIS ITERATION IF WE'VE FINISHED NEARLY EVERY PATH, OR ELSE COMPUTE NEW INTERSECTIONS + if (num_paths == 0) iterationComplete = true; + else { + cudaMemset(dev_intersections, 0, num_paths * sizeof(ShadeableIntersection)); + // tracing + numblocksPathSegmentTracing = (num_paths + blockSize1d - 1) / blockSize1d; + computeIntersections << > > (depth, num_paths, dev_paths, dev_geoms, + hst_scene->geoms.size(), dev_intersections); + checkCUDAError("trace one bounce"); + cudaDeviceSynchronize(); + depth++; + } } - // Assemble this iteration and apply it to the image - dim3 numBlocksPixels = (pixelcount + blockSize1d - 1) / blockSize1d; - finalGather<<>>(num_paths, dev_image, dev_paths); - - /////////////////////////////////////////////////////////////////////////// + //FINAL GATHER + finalGather << > >(num_paths, dev_image, dev_paths); //----------------------------------------- add final contributions to the frame - // Send results to OpenGL buffer for rendering - sendImageToPBO<<>>(pbo, cam.resolution, iter, dev_image); + /////////////////////////////////////////////////////////////////////////// + if (true || iter % 1 == 0 && iter > 1) { + // Send results to OpenGL buffer for rendering + sendImageToPBO << > > (pbo, cam.resolution, iter, dev_image); - // Retrieve image from GPU - cudaMemcpy(hst_scene->state.image.data(), dev_image, - pixelcount * sizeof(glm::vec3), cudaMemcpyDeviceToHost); - - checkCUDAError("pathtrace"); + // Retrieve image from GPU + cudaMemcpy(hst_scene->state.image.data(), dev_image, + pixelcount * sizeof(glm::vec3), cudaMemcpyDeviceToHost); + } + checkCUDAError("pathtrace"); } diff --git a/src/scene.cpp b/src/scene.cpp index cbae043..c4f3dd1 100644 --- a/src/scene.cpp +++ b/src/scene.cpp @@ -4,6 +4,9 @@ #include #include +#define TINYOBJLOADER_IMPLEMENTATION +#include "tiny_obj_loader.h" + Scene::Scene(string filename) { cout << "Reading scene from " << filename << " ..." << endl; cout << " " << endl; @@ -27,7 +30,9 @@ Scene::Scene(string filename) { } else if (strcmp(tokens[0].c_str(), "CAMERA") == 0) { loadCamera(); cout << " " << endl; - } + } else if (strcmp(tokens[0].c_str(), "END") == 0) { + break; + } } } } @@ -41,6 +46,7 @@ int Scene::loadGeom(string objectid) { cout << "Loading Geom " << id << "..." << endl; Geom newGeom; string line; + string meshName; //load object type utilityCore::safeGetline(fp_in, line); @@ -51,7 +57,11 @@ int Scene::loadGeom(string objectid) { } else if (strcmp(line.c_str(), "cube") == 0) { cout << "Creating new cube..." << endl; newGeom.type = CUBE; - } + } + else { + newGeom.type = BB; + meshName = line.c_str(); + } } //link material @@ -79,16 +89,93 @@ int Scene::loadGeom(string objectid) { utilityCore::safeGetline(fp_in, line); } - newGeom.transform = utilityCore::buildTransformationMatrix( - newGeom.translation, newGeom.rotation, newGeom.scale); - newGeom.inverseTransform = glm::inverse(newGeom.transform); - newGeom.invTranspose = glm::inverseTranspose(newGeom.transform); + newGeom.transform = utilityCore::buildTransformationMatrix( + newGeom.translation, newGeom.rotation, newGeom.scale); + newGeom.inverseTransform = glm::inverse(newGeom.transform); + newGeom.invTranspose = glm::inverseTranspose(newGeom.transform); + + if (newGeom.type == SPHERE || newGeom.type == CUBE) { + geoms.push_back(newGeom); + } else { + geoms.push_back(newGeom); + loadObj(meshName, newGeom.transform, newGeom.inverseTransform, newGeom.invTranspose, newGeom.materialid); + } - geoms.push_back(newGeom); return 1; } } +//straight from the tinyOBJ readme +int Scene::loadObj(string meshName, glm::mat4 transform, glm::mat4 inverseTransform, glm::mat4 inverseTranspose, int materialID) { + + Geom bb = geoms[geoms.size() - 1]; + int bbIdx = geoms.size() - 1; + glm::vec3 minPoint = glm::vec3(100, 100, 100); + glm::vec3 maxPoint = glm::vec3(-100, -100, -100); + + tinyobj::attrib_t attrib; + std::vector shapes; + std::vector materials; + + std::string err; + bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, meshName.c_str(),NULL,true); + + if (!err.empty()) { // `err` may contain warning message. + std::cerr << err << std::endl; + } + + if (!ret) { + exit(1); + } + + // Loop over shapes + for (size_t s = 0; s < shapes.size(); s++) { + + // Loop over faces(polygon) + size_t index_offset = 0; + for (size_t f = 0; f < shapes[s].mesh.num_face_vertices.size(); f++) { + Geom newGeom; + newGeom.type = TRIANGLE; + newGeom.materialid = materialID; + newGeom.transform = transform; + newGeom.inverseTransform = inverseTransform; + newGeom.invTranspose = inverseTranspose; + + // Loop over vertices in the face. + for (size_t v = 0; v < 3; v++) { + // access to vertex + tinyobj::index_t idx = shapes[s].mesh.indices[index_offset + v]; + newGeom.vertices[v][0] = attrib.vertices[3 * idx.vertex_index + 0]; + newGeom.vertices[v][1] = attrib.vertices[3 * idx.vertex_index + 1]; + newGeom.vertices[v][2] = attrib.vertices[3 * idx.vertex_index + 2]; + } + + for (int i = 0; i < 3; i++) { + newGeom.vertices[i] = (glm::vec3) (transform * glm::vec4(newGeom.vertices[i],1)); + minPoint = glm::min(newGeom.vertices[i], minPoint); + maxPoint = glm::max(newGeom.vertices[i], maxPoint); + } + newGeom.normal = glm::normalize(glm::cross(newGeom.vertices[1] - newGeom.vertices[0], newGeom.vertices[2] - newGeom.vertices[0])); + + geoms.push_back(newGeom); + index_offset += 3; + } + } + + bb.translation = 0.5f * (minPoint + maxPoint); + bb.rotation = glm::vec3(0, 0, 0); + bb.scale = maxPoint - minPoint; + bb.materialid = materialID; + bb.transform = utilityCore::buildTransformationMatrix( + bb.translation, bb.rotation, bb.scale); + bb.inverseTransform = glm::inverse(bb.transform); + bb.invTranspose = glm::inverseTranspose(bb.transform); + bb.numTris = geoms.size() - bbIdx; + geoms[bbIdx] = bb; + + return 1; +} + int Scene::loadCamera() { cout << "Loading Camera ..." << endl; RenderState &state = this->state; diff --git a/src/scene.h b/src/scene.h index f29a917..9292ff4 100644 --- a/src/scene.h +++ b/src/scene.h @@ -15,6 +15,7 @@ class Scene { ifstream fp_in; int loadMaterial(string materialid); int loadGeom(string objectid); + int loadObj(string meshName, glm::mat4 transform, glm::mat4 inverseTransform, glm::mat4 inverseTranspose, int materialID); int loadCamera(); public: Scene(string filename); diff --git a/src/sceneStructs.h b/src/sceneStructs.h index b38b820..5288f17 100644 --- a/src/sceneStructs.h +++ b/src/sceneStructs.h @@ -10,6 +10,8 @@ enum GeomType { SPHERE, CUBE, + TRIANGLE, + BB }; struct Ray { @@ -19,6 +21,9 @@ struct Ray { struct Geom { enum GeomType type; + glm::vec3 vertices[3];//if triangle + glm::vec3 normal; + int numTris; int materialid; glm::vec3 translation; glm::vec3 rotation; @@ -64,6 +69,7 @@ struct PathSegment { glm::vec3 color; int pixelIndex; int remainingBounces; + float insideT; //will be zero except if inside a refractive surface; there it will reflect distance traveled for beers law }; // Use with a corresponding PathSegment to do: @@ -71,6 +77,7 @@ struct PathSegment { // 2) BSDF evaluation: generate a new ray struct ShadeableIntersection { float t; + glm::vec3 point; glm::vec3 surfaceNormal; int materialId; }; diff --git a/src/tiny_obj_loader.h b/src/tiny_obj_loader.h new file mode 100644 index 0000000..5abe459 --- /dev/null +++ b/src/tiny_obj_loader.h @@ -0,0 +1,2125 @@ +/* +The MIT License (MIT) +Copyright (c) 2012-2017 Syoyo Fujita and many contributors. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +// +// version 1.1.0 : Support parsing vertex color(#144) +// version 1.0.8 : Fix parsing `g` tag just after `usemtl`(#138) +// version 1.0.7 : Support multiple tex options(#126) +// version 1.0.6 : Add TINYOBJLOADER_USE_DOUBLE option(#124) +// version 1.0.5 : Ignore `Tr` when `d` exists in MTL(#43) +// version 1.0.4 : Support multiple filenames for 'mtllib'(#112) +// version 1.0.3 : Support parsing texture options(#85) +// version 1.0.2 : Improve parsing speed by about a factor of 2 for large +// files(#105) +// version 1.0.1 : Fixes a shape is lost if obj ends with a 'usemtl'(#104) +// version 1.0.0 : Change data structure. Change license from BSD to MIT. +// + + +#ifndef TINY_OBJ_LOADER_H_ +#define TINY_OBJ_LOADER_H_ + +#include +#include +#include + +namespace tinyobj { + + // https://en.wikipedia.org/wiki/Wavefront_.obj_file says ... + // + // -blendu on | off # set horizontal texture blending + // (default on) + // -blendv on | off # set vertical texture blending + // (default on) + // -boost real_value # boost mip-map sharpness + // -mm base_value gain_value # modify texture map values (default + // 0 1) + // # base_value = brightness, + // gain_value = contrast + // -o u [v [w]] # Origin offset (default + // 0 0 0) + // -s u [v [w]] # Scale (default + // 1 1 1) + // -t u [v [w]] # Turbulence (default + // 0 0 0) + // -texres resolution # texture resolution to create + // -clamp on | off # only render texels in the clamped + // 0-1 range (default off) + // # When unclamped, textures are + // repeated across a surface, + // # when clamped, only texels which + // fall within the 0-1 + // # range are rendered. + // -bm mult_value # bump multiplier (for bump maps + // only) + // + // -imfchan r | g | b | m | l | z # specifies which channel of the file + // is used to + // # create a scalar or bump texture. + // r:red, g:green, + // # b:blue, m:matte, l:luminance, + // z:z-depth.. + // # (the default for bump is 'l' and + // for decal is 'm') + // bump -imfchan r bumpmap.tga # says to use the red channel of + // bumpmap.tga as the bumpmap + // + // For reflection maps... + // + // -type sphere # specifies a sphere for a "refl" + // reflection map + // -type cube_top | cube_bottom | # when using a cube map, the texture + // file for each + // cube_front | cube_back | # side of the cube is specified + // separately + // cube_left | cube_right + +#ifdef TINYOBJLOADER_USE_DOUBLE + //#pragma message "using double" + typedef double real_t; +#else + //#pragma message "using float" + typedef float real_t; +#endif + + typedef enum { + TEXTURE_TYPE_NONE, // default + TEXTURE_TYPE_SPHERE, + TEXTURE_TYPE_CUBE_TOP, + TEXTURE_TYPE_CUBE_BOTTOM, + TEXTURE_TYPE_CUBE_FRONT, + TEXTURE_TYPE_CUBE_BACK, + TEXTURE_TYPE_CUBE_LEFT, + TEXTURE_TYPE_CUBE_RIGHT + } texture_type_t; + + typedef struct { + texture_type_t type; // -type (default TEXTURE_TYPE_NONE) + real_t sharpness; // -boost (default 1.0?) + real_t brightness; // base_value in -mm option (default 0) + real_t contrast; // gain_value in -mm option (default 1) + real_t origin_offset[3]; // -o u [v [w]] (default 0 0 0) + real_t scale[3]; // -s u [v [w]] (default 1 1 1) + real_t turbulence[3]; // -t u [v [w]] (default 0 0 0) + // int texture_resolution; // -texres resolution (default = ?) TODO + bool clamp; // -clamp (default false) + char imfchan; // -imfchan (the default for bump is 'l' and for decal is 'm') + bool blendu; // -blendu (default on) + bool blendv; // -blendv (default on) + real_t bump_multiplier; // -bm (for bump maps only, default 1.0) + } texture_option_t; + + typedef struct { + std::string name; + + real_t ambient[3]; + real_t diffuse[3]; + real_t specular[3]; + real_t transmittance[3]; + real_t emission[3]; + real_t shininess; + real_t ior; // index of refraction + real_t dissolve; // 1 == opaque; 0 == fully transparent + // illumination model (see http://www.fileformat.info/format/material/) + int illum; + + int dummy; // Suppress padding warning. + + std::string ambient_texname; // map_Ka + std::string diffuse_texname; // map_Kd + std::string specular_texname; // map_Ks + std::string specular_highlight_texname; // map_Ns + std::string bump_texname; // map_bump, map_Bump, bump + std::string displacement_texname; // disp + std::string alpha_texname; // map_d + std::string reflection_texname; // refl + + texture_option_t ambient_texopt; + texture_option_t diffuse_texopt; + texture_option_t specular_texopt; + texture_option_t specular_highlight_texopt; + texture_option_t bump_texopt; + texture_option_t displacement_texopt; + texture_option_t alpha_texopt; + texture_option_t reflection_texopt; + + // PBR extension + // http://exocortex.com/blog/extending_wavefront_mtl_to_support_pbr + real_t roughness; // [0, 1] default 0 + real_t metallic; // [0, 1] default 0 + real_t sheen; // [0, 1] default 0 + real_t clearcoat_thickness; // [0, 1] default 0 + real_t clearcoat_roughness; // [0, 1] default 0 + real_t anisotropy; // aniso. [0, 1] default 0 + real_t anisotropy_rotation; // anisor. [0, 1] default 0 + real_t pad0; + std::string roughness_texname; // map_Pr + std::string metallic_texname; // map_Pm + std::string sheen_texname; // map_Ps + std::string emissive_texname; // map_Ke + std::string normal_texname; // norm. For normal mapping. + + texture_option_t roughness_texopt; + texture_option_t metallic_texopt; + texture_option_t sheen_texopt; + texture_option_t emissive_texopt; + texture_option_t normal_texopt; + + int pad2; + + std::map unknown_parameter; + } material_t; + + typedef struct { + std::string name; + + std::vector intValues; + std::vector floatValues; + std::vector stringValues; + } tag_t; + + // Index struct to support different indices for vtx/normal/texcoord. + // -1 means not used. + typedef struct { + int vertex_index; + int normal_index; + int texcoord_index; + } index_t; + + typedef struct { + std::vector indices; + std::vector num_face_vertices; // The number of vertices per + // face. 3 = polygon, 4 = quad, + // ... Up to 255. + std::vector material_ids; // per-face material ID + std::vector tags; // SubD tag + } mesh_t; + + typedef struct { + std::string name; + mesh_t mesh; + } shape_t; + + // Vertex attributes + typedef struct { + std::vector vertices; // 'v' + std::vector normals; // 'vn' + std::vector texcoords; // 'vt' + std::vector colors; // extension: vertex colors + } attrib_t; + + typedef struct callback_t_ { + // W is optional and set to 1 if there is no `w` item in `v` line + void(*vertex_cb)(void *user_data, real_t x, real_t y, real_t z, real_t w); + void(*normal_cb)(void *user_data, real_t x, real_t y, real_t z); + + // y and z are optional and set to 0 if there is no `y` and/or `z` item(s) in + // `vt` line. + void(*texcoord_cb)(void *user_data, real_t x, real_t y, real_t z); + + // called per 'f' line. num_indices is the number of face indices(e.g. 3 for + // triangle, 4 for quad) + // 0 will be passed for undefined index in index_t members. + void(*index_cb)(void *user_data, index_t *indices, int num_indices); + // `name` material name, `material_id` = the array index of material_t[]. -1 + // if + // a material not found in .mtl + void(*usemtl_cb)(void *user_data, const char *name, int material_id); + // `materials` = parsed material data. + void(*mtllib_cb)(void *user_data, const material_t *materials, + int num_materials); + // There may be multiple group names + void(*group_cb)(void *user_data, const char **names, int num_names); + void(*object_cb)(void *user_data, const char *name); + + callback_t_() + : vertex_cb(NULL), + normal_cb(NULL), + texcoord_cb(NULL), + index_cb(NULL), + usemtl_cb(NULL), + mtllib_cb(NULL), + group_cb(NULL), + object_cb(NULL) {} + } callback_t; + + class MaterialReader { + public: + MaterialReader() {} + virtual ~MaterialReader(); + + virtual bool operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, + std::string *err) = 0; + }; + + class MaterialFileReader : public MaterialReader { + public: + explicit MaterialFileReader(const std::string &mtl_basedir) + : m_mtlBaseDir(mtl_basedir) {} + virtual ~MaterialFileReader() {} + virtual bool operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, std::string *err); + + private: + std::string m_mtlBaseDir; + }; + + class MaterialStreamReader : public MaterialReader { + public: + explicit MaterialStreamReader(std::istream &inStream) + : m_inStream(inStream) {} + virtual ~MaterialStreamReader() {} + virtual bool operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, std::string *err); + + private: + std::istream &m_inStream; + }; + + /// Loads .obj from a file. + /// 'attrib', 'shapes' and 'materials' will be filled with parsed shape data + /// 'shapes' will be filled with parsed shape data + /// Returns true when loading .obj become success. + /// Returns warning and error message into `err` + /// 'mtl_basedir' is optional, and used for base directory for .mtl file. + /// In default(`NULL'), .mtl file is searched from an application's working + /// directory. + /// 'triangulate' is optional, and used whether triangulate polygon face in .obj + /// or not. + bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *err, + const char *filename, const char *mtl_basedir = NULL, + bool triangulate = true); + + /// Loads .obj from a file with custom user callback. + /// .mtl is loaded as usual and parsed material_t data will be passed to + /// `callback.mtllib_cb`. + /// Returns true when loading .obj/.mtl become success. + /// Returns warning and error message into `err` + /// See `examples/callback_api/` for how to use this function. + bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback, + void *user_data = NULL, + MaterialReader *readMatFn = NULL, + std::string *err = NULL); + + /// Loads object from a std::istream, uses GetMtlIStreamFn to retrieve + /// std::istream for materials. + /// Returns true when loading .obj become success. + /// Returns warning and error message into `err` + bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *err, + std::istream *inStream, MaterialReader *readMatFn = NULL, + bool triangulate = true); + + /// Loads materials into std::map + void LoadMtl(std::map *material_map, + std::vector *materials, std::istream *inStream, + std::string *warning); + +} // namespace tinyobj + +#endif // TINY_OBJ_LOADER_H_ + +#ifdef TINYOBJLOADER_IMPLEMENTATION + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace tinyobj { + + MaterialReader::~MaterialReader() {} + + struct vertex_index { + int v_idx, vt_idx, vn_idx; + vertex_index() : v_idx(-1), vt_idx(-1), vn_idx(-1) {} + explicit vertex_index(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {} + vertex_index(int vidx, int vtidx, int vnidx) + : v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {} + }; + + struct tag_sizes { + tag_sizes() : num_ints(0), num_reals(0), num_strings(0) {} + int num_ints; + int num_reals; + int num_strings; + }; + + struct obj_shape { + std::vector v; + std::vector vn; + std::vector vt; + }; + + // See + // http://stackoverflow.com/questions/6089231/getting-std-ifstream-to-handle-lf-cr-and-crlf + static std::istream &safeGetline(std::istream &is, std::string &t) { + t.clear(); + + // The characters in the stream are read one-by-one using a std::streambuf. + // That is faster than reading them one-by-one using the std::istream. + // Code that uses streambuf this way must be guarded by a sentry object. + // The sentry object performs various tasks, + // such as thread synchronization and updating the stream state. + + std::istream::sentry se(is, true); + std::streambuf *sb = is.rdbuf(); + + if (se) { + for (;;) { + int c = sb->sbumpc(); + switch (c) { + case '\n': + return is; + case '\r': + if (sb->sgetc() == '\n') sb->sbumpc(); + return is; + case EOF: + // Also handle the case when the last line has no line ending + if (t.empty()) is.setstate(std::ios::eofbit); + return is; + default: + t += static_cast(c); + } + } + } + + return is; + } + +#define IS_SPACE(x) (((x) == ' ') || ((x) == '\t')) +#define IS_DIGIT(x) \ + (static_cast((x) - '0') < static_cast(10)) +#define IS_NEW_LINE(x) (((x) == '\r') || ((x) == '\n') || ((x) == '\0')) + + // Make index zero-base, and also support relative index. + static inline bool fixIndex(int idx, int n, int *ret) { + if (!ret) { + return false; + } + + if (idx > 0) { + (*ret) = idx - 1; + return true; + } + + if (idx == 0) { + // zero is not allowed according to the spec. + return false; + } + + if (idx < 0) { + (*ret) = n + idx; // negative value = relative + return true; + } + + return false; // never reach here. + } + + static inline std::string parseString(const char **token) { + std::string s; + (*token) += strspn((*token), " \t"); + size_t e = strcspn((*token), " \t\r"); + s = std::string((*token), &(*token)[e]); + (*token) += e; + return s; + } + + static inline int parseInt(const char **token) { + (*token) += strspn((*token), " \t"); + int i = atoi((*token)); + (*token) += strcspn((*token), " \t\r"); + return i; + } + + // Tries to parse a floating point number located at s. + // + // s_end should be a location in the string where reading should absolutely + // stop. For example at the end of the string, to prevent buffer overflows. + // + // Parses the following EBNF grammar: + // sign = "+" | "-" ; + // END = ? anything not in digit ? + // digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; + // integer = [sign] , digit , {digit} ; + // decimal = integer , ["." , integer] ; + // float = ( decimal , END ) | ( decimal , ("E" | "e") , integer , END ) ; + // + // Valid strings are for example: + // -0 +3.1417e+2 -0.0E-3 1.0324 -1.41 11e2 + // + // If the parsing is a success, result is set to the parsed value and true + // is returned. + // + // The function is greedy and will parse until any of the following happens: + // - a non-conforming character is encountered. + // - s_end is reached. + // + // The following situations triggers a failure: + // - s >= s_end. + // - parse failure. + // + static bool tryParseDouble(const char *s, const char *s_end, double *result) { + if (s >= s_end) { + return false; + } + + double mantissa = 0.0; + // This exponent is base 2 rather than 10. + // However the exponent we parse is supposed to be one of ten, + // thus we must take care to convert the exponent/and or the + // mantissa to a * 2^E, where a is the mantissa and E is the + // exponent. + // To get the final double we will use ldexp, it requires the + // exponent to be in base 2. + int exponent = 0; + + // NOTE: THESE MUST BE DECLARED HERE SINCE WE ARE NOT ALLOWED + // TO JUMP OVER DEFINITIONS. + char sign = '+'; + char exp_sign = '+'; + char const *curr = s; + + // How many characters were read in a loop. + int read = 0; + // Tells whether a loop terminated due to reaching s_end. + bool end_not_reached = false; + + /* + BEGIN PARSING. + */ + + // Find out what sign we've got. + if (*curr == '+' || *curr == '-') { + sign = *curr; + curr++; + } + else if (IS_DIGIT(*curr)) { /* Pass through. */ + } + else { + goto fail; + } + + // Read the integer part. + end_not_reached = (curr != s_end); + while (end_not_reached && IS_DIGIT(*curr)) { + mantissa *= 10; + mantissa += static_cast(*curr - 0x30); + curr++; + read++; + end_not_reached = (curr != s_end); + } + + // We must make sure we actually got something. + if (read == 0) goto fail; + // We allow numbers of form "#", "###" etc. + if (!end_not_reached) goto assemble; + + // Read the decimal part. + if (*curr == '.') { + curr++; + read = 1; + end_not_reached = (curr != s_end); + while (end_not_reached && IS_DIGIT(*curr)) { + static const double pow_lut[] = { + 1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001, + }; + const int lut_entries = sizeof pow_lut / sizeof pow_lut[0]; + + // NOTE: Don't use powf here, it will absolutely murder precision. + mantissa += static_cast(*curr - 0x30) * + (read < lut_entries ? pow_lut[read] : std::pow(10.0, -read)); + read++; + curr++; + end_not_reached = (curr != s_end); + } + } + else if (*curr == 'e' || *curr == 'E') { + } + else { + goto assemble; + } + + if (!end_not_reached) goto assemble; + + // Read the exponent part. + if (*curr == 'e' || *curr == 'E') { + curr++; + // Figure out if a sign is present and if it is. + end_not_reached = (curr != s_end); + if (end_not_reached && (*curr == '+' || *curr == '-')) { + exp_sign = *curr; + curr++; + } + else if (IS_DIGIT(*curr)) { /* Pass through. */ + } + else { + // Empty E is not allowed. + goto fail; + } + + read = 0; + end_not_reached = (curr != s_end); + while (end_not_reached && IS_DIGIT(*curr)) { + exponent *= 10; + exponent += static_cast(*curr - 0x30); + curr++; + read++; + end_not_reached = (curr != s_end); + } + exponent *= (exp_sign == '+' ? 1 : -1); + if (read == 0) goto fail; + } + + assemble: + *result = (sign == '+' ? 1 : -1) * + (exponent ? std::ldexp(mantissa * std::pow(5.0, exponent), exponent) + : mantissa); + return true; + fail: + return false; + } + + static inline real_t parseReal(const char **token, double default_value = 0.0) { + (*token) += strspn((*token), " \t"); + const char *end = (*token) + strcspn((*token), " \t\r"); + double val = default_value; + tryParseDouble((*token), end, &val); + real_t f = static_cast(val); + (*token) = end; + return f; + } + + static inline bool parseReal(const char **token, real_t *out) { + (*token) += strspn((*token), " \t"); + const char *end = (*token) + strcspn((*token), " \t\r"); + double val; + bool ret = tryParseDouble((*token), end, &val); + if (ret) { + real_t f = static_cast(val); + (*out) = f; + } + (*token) = end; + return ret; + } + + static inline void parseReal2(real_t *x, real_t *y, const char **token, + const double default_x = 0.0, + const double default_y = 0.0) { + (*x) = parseReal(token, default_x); + (*y) = parseReal(token, default_y); + } + + static inline void parseReal3(real_t *x, real_t *y, real_t *z, + const char **token, const double default_x = 0.0, + const double default_y = 0.0, + const double default_z = 0.0) { + (*x) = parseReal(token, default_x); + (*y) = parseReal(token, default_y); + (*z) = parseReal(token, default_z); + } + + static inline void parseV(real_t *x, real_t *y, real_t *z, real_t *w, + const char **token, const double default_x = 0.0, + const double default_y = 0.0, + const double default_z = 0.0, + const double default_w = 1.0) { + (*x) = parseReal(token, default_x); + (*y) = parseReal(token, default_y); + (*z) = parseReal(token, default_z); + (*w) = parseReal(token, default_w); + } + + // Extension: parse vertex with colors(6 items) + static inline bool parseVertexWithColor(real_t *x, real_t *y, real_t *z, real_t *r, + real_t *g, real_t *b, + const char **token, const double default_x = 0.0, + const double default_y = 0.0, + const double default_z = 0.0) { + (*x) = parseReal(token, default_x); + (*y) = parseReal(token, default_y); + (*z) = parseReal(token, default_z); + + (*r) = parseReal(token, 1.0); + (*g) = parseReal(token, 1.0); + (*b) = parseReal(token, 1.0); + + return true; + } + + static inline bool parseOnOff(const char **token, bool default_value = true) { + (*token) += strspn((*token), " \t"); + const char *end = (*token) + strcspn((*token), " \t\r"); + + bool ret = default_value; + if ((0 == strncmp((*token), "on", 2))) { + ret = true; + } + else if ((0 == strncmp((*token), "off", 3))) { + ret = false; + } + + (*token) = end; + return ret; + } + + static inline texture_type_t parseTextureType( + const char **token, texture_type_t default_value = TEXTURE_TYPE_NONE) { + (*token) += strspn((*token), " \t"); + const char *end = (*token) + strcspn((*token), " \t\r"); + texture_type_t ty = default_value; + + if ((0 == strncmp((*token), "cube_top", strlen("cube_top")))) { + ty = TEXTURE_TYPE_CUBE_TOP; + } + else if ((0 == strncmp((*token), "cube_bottom", strlen("cube_bottom")))) { + ty = TEXTURE_TYPE_CUBE_BOTTOM; + } + else if ((0 == strncmp((*token), "cube_left", strlen("cube_left")))) { + ty = TEXTURE_TYPE_CUBE_LEFT; + } + else if ((0 == strncmp((*token), "cube_right", strlen("cube_right")))) { + ty = TEXTURE_TYPE_CUBE_RIGHT; + } + else if ((0 == strncmp((*token), "cube_front", strlen("cube_front")))) { + ty = TEXTURE_TYPE_CUBE_FRONT; + } + else if ((0 == strncmp((*token), "cube_back", strlen("cube_back")))) { + ty = TEXTURE_TYPE_CUBE_BACK; + } + else if ((0 == strncmp((*token), "sphere", strlen("sphere")))) { + ty = TEXTURE_TYPE_SPHERE; + } + + (*token) = end; + return ty; + } + + static tag_sizes parseTagTriple(const char **token) { + tag_sizes ts; + + (*token) += strspn((*token), " \t"); + ts.num_ints = atoi((*token)); + (*token) += strcspn((*token), "/ \t\r"); + if ((*token)[0] != '/') { + return ts; + } + + (*token)++; // Skip '/' + + (*token) += strspn((*token), " \t"); + ts.num_reals = atoi((*token)); + (*token) += strcspn((*token), "/ \t\r"); + if ((*token)[0] != '/') { + return ts; + } + (*token)++; // Skip '/' + + ts.num_strings = parseInt(token); + + return ts; + } + + // Parse triples with index offsets: i, i/j/k, i//k, i/j + static bool parseTriple(const char **token, int vsize, int vnsize, int vtsize, + vertex_index *ret) { + if (!ret) { + return false; + } + + vertex_index vi(-1); + + if (!fixIndex(atoi((*token)), vsize, &(vi.v_idx))) { + return false; + } + + (*token) += strcspn((*token), "/ \t\r"); + if ((*token)[0] != '/') { + (*ret) = vi; + return true; + } + (*token)++; + + // i//k + if ((*token)[0] == '/') { + (*token)++; + if (!fixIndex(atoi((*token)), vnsize, &(vi.vn_idx))) { + return false; + } + (*token) += strcspn((*token), "/ \t\r"); + (*ret) = vi; + return true; + } + + // i/j/k or i/j + if (!fixIndex(atoi((*token)), vtsize, &(vi.vt_idx))) { + return false; + } + + (*token) += strcspn((*token), "/ \t\r"); + if ((*token)[0] != '/') { + (*ret) = vi; + return true; + } + + // i/j/k + (*token)++; // skip '/' + if (!fixIndex(atoi((*token)), vnsize, &(vi.vn_idx))) { + return false; + } + (*token) += strcspn((*token), "/ \t\r"); + + (*ret) = vi; + + return true; + } + + // Parse raw triples: i, i/j/k, i//k, i/j + static vertex_index parseRawTriple(const char **token) { + vertex_index vi(static_cast(0)); // 0 is an invalid index in OBJ + + vi.v_idx = atoi((*token)); + (*token) += strcspn((*token), "/ \t\r"); + if ((*token)[0] != '/') { + return vi; + } + (*token)++; + + // i//k + if ((*token)[0] == '/') { + (*token)++; + vi.vn_idx = atoi((*token)); + (*token) += strcspn((*token), "/ \t\r"); + return vi; + } + + // i/j/k or i/j + vi.vt_idx = atoi((*token)); + (*token) += strcspn((*token), "/ \t\r"); + if ((*token)[0] != '/') { + return vi; + } + + // i/j/k + (*token)++; // skip '/' + vi.vn_idx = atoi((*token)); + (*token) += strcspn((*token), "/ \t\r"); + return vi; + } + + static bool ParseTextureNameAndOption(std::string *texname, + texture_option_t *texopt, + const char *linebuf, const bool is_bump) { + // @todo { write more robust lexer and parser. } + bool found_texname = false; + std::string texture_name; + + // Fill with default value for texopt. + if (is_bump) { + texopt->imfchan = 'l'; + } + else { + texopt->imfchan = 'm'; + } + texopt->bump_multiplier = 1.0f; + texopt->clamp = false; + texopt->blendu = true; + texopt->blendv = true; + texopt->sharpness = 1.0f; + texopt->brightness = 0.0f; + texopt->contrast = 1.0f; + texopt->origin_offset[0] = 0.0f; + texopt->origin_offset[1] = 0.0f; + texopt->origin_offset[2] = 0.0f; + texopt->scale[0] = 1.0f; + texopt->scale[1] = 1.0f; + texopt->scale[2] = 1.0f; + texopt->turbulence[0] = 0.0f; + texopt->turbulence[1] = 0.0f; + texopt->turbulence[2] = 0.0f; + texopt->type = TEXTURE_TYPE_NONE; + + const char *token = linebuf; // Assume line ends with NULL + + while (!IS_NEW_LINE((*token))) { + token += strspn(token, " \t"); // skip space + if ((0 == strncmp(token, "-blendu", 7)) && IS_SPACE((token[7]))) { + token += 8; + texopt->blendu = parseOnOff(&token, /* default */ true); + } + else if ((0 == strncmp(token, "-blendv", 7)) && IS_SPACE((token[7]))) { + token += 8; + texopt->blendv = parseOnOff(&token, /* default */ true); + } + else if ((0 == strncmp(token, "-clamp", 6)) && IS_SPACE((token[6]))) { + token += 7; + texopt->clamp = parseOnOff(&token, /* default */ true); + } + else if ((0 == strncmp(token, "-boost", 6)) && IS_SPACE((token[6]))) { + token += 7; + texopt->sharpness = parseReal(&token, 1.0); + } + else if ((0 == strncmp(token, "-bm", 3)) && IS_SPACE((token[3]))) { + token += 4; + texopt->bump_multiplier = parseReal(&token, 1.0); + } + else if ((0 == strncmp(token, "-o", 2)) && IS_SPACE((token[2]))) { + token += 3; + parseReal3(&(texopt->origin_offset[0]), &(texopt->origin_offset[1]), + &(texopt->origin_offset[2]), &token); + } + else if ((0 == strncmp(token, "-s", 2)) && IS_SPACE((token[2]))) { + token += 3; + parseReal3(&(texopt->scale[0]), &(texopt->scale[1]), &(texopt->scale[2]), + &token, 1.0, 1.0, 1.0); + } + else if ((0 == strncmp(token, "-t", 2)) && IS_SPACE((token[2]))) { + token += 3; + parseReal3(&(texopt->turbulence[0]), &(texopt->turbulence[1]), + &(texopt->turbulence[2]), &token); + } + else if ((0 == strncmp(token, "-type", 5)) && IS_SPACE((token[5]))) { + token += 5; + texopt->type = parseTextureType((&token), TEXTURE_TYPE_NONE); + } + else if ((0 == strncmp(token, "-imfchan", 8)) && IS_SPACE((token[8]))) { + token += 9; + token += strspn(token, " \t"); + const char *end = token + strcspn(token, " \t\r"); + if ((end - token) == 1) { // Assume one char for -imfchan + texopt->imfchan = (*token); + } + token = end; + } + else if ((0 == strncmp(token, "-mm", 3)) && IS_SPACE((token[3]))) { + token += 4; + parseReal2(&(texopt->brightness), &(texopt->contrast), &token, 0.0, 1.0); + } + else { + // Assume texture filename +#if 0 + size_t len = strcspn(token, " \t\r"); // untile next space + texture_name = std::string(token, token + len); + token += len; + token += strspn(token, " \t"); // skip space +#else + // Read filename until line end to parse filename containing whitespace + // TODO(syoyo): Support parsing texture option flag after the filename. + texture_name = std::string(token); + token += texture_name.length(); +#endif + + found_texname = true; + } + } + + if (found_texname) { + (*texname) = texture_name; + return true; + } + else { + return false; + } + } + + static void InitMaterial(material_t *material) { + material->name = ""; + material->ambient_texname = ""; + material->diffuse_texname = ""; + material->specular_texname = ""; + material->specular_highlight_texname = ""; + material->bump_texname = ""; + material->displacement_texname = ""; + material->reflection_texname = ""; + material->alpha_texname = ""; + for (int i = 0; i < 3; i++) { + material->ambient[i] = 0.f; + material->diffuse[i] = 0.f; + material->specular[i] = 0.f; + material->transmittance[i] = 0.f; + material->emission[i] = 0.f; + } + material->illum = 0; + material->dissolve = 1.f; + material->shininess = 1.f; + material->ior = 1.f; + + material->roughness = 0.f; + material->metallic = 0.f; + material->sheen = 0.f; + material->clearcoat_thickness = 0.f; + material->clearcoat_roughness = 0.f; + material->anisotropy_rotation = 0.f; + material->anisotropy = 0.f; + material->roughness_texname = ""; + material->metallic_texname = ""; + material->sheen_texname = ""; + material->emissive_texname = ""; + material->normal_texname = ""; + + material->unknown_parameter.clear(); + } + + static bool exportFaceGroupToShape( + shape_t *shape, const std::vector > &faceGroup, + const std::vector &tags, const int material_id, + const std::string &name, bool triangulate) { + if (faceGroup.empty()) { + return false; + } + + // Flatten vertices and indices + for (size_t i = 0; i < faceGroup.size(); i++) { + const std::vector &face = faceGroup[i]; + + vertex_index i0 = face[0]; + vertex_index i1(-1); + vertex_index i2 = face[1]; + + size_t npolys = face.size(); + + if (triangulate) { + // Polygon -> triangle fan conversion + for (size_t k = 2; k < npolys; k++) { + i1 = i2; + i2 = face[k]; + + index_t idx0, idx1, idx2; + idx0.vertex_index = i0.v_idx; + idx0.normal_index = i0.vn_idx; + idx0.texcoord_index = i0.vt_idx; + idx1.vertex_index = i1.v_idx; + idx1.normal_index = i1.vn_idx; + idx1.texcoord_index = i1.vt_idx; + idx2.vertex_index = i2.v_idx; + idx2.normal_index = i2.vn_idx; + idx2.texcoord_index = i2.vt_idx; + + shape->mesh.indices.push_back(idx0); + shape->mesh.indices.push_back(idx1); + shape->mesh.indices.push_back(idx2); + + shape->mesh.num_face_vertices.push_back(3); + shape->mesh.material_ids.push_back(material_id); + } + } + else { + for (size_t k = 0; k < npolys; k++) { + index_t idx; + idx.vertex_index = face[k].v_idx; + idx.normal_index = face[k].vn_idx; + idx.texcoord_index = face[k].vt_idx; + shape->mesh.indices.push_back(idx); + } + + shape->mesh.num_face_vertices.push_back( + static_cast(npolys)); + shape->mesh.material_ids.push_back(material_id); // per face + } + } + + shape->name = name; + shape->mesh.tags = tags; + + return true; + } + + // Split a string with specified delimiter character. + // http://stackoverflow.com/questions/236129/split-a-string-in-c + static void SplitString(const std::string &s, char delim, + std::vector &elems) { + std::stringstream ss; + ss.str(s); + std::string item; + while (std::getline(ss, item, delim)) { + elems.push_back(item); + } + } + + void LoadMtl(std::map *material_map, + std::vector *materials, std::istream *inStream, + std::string *warning) { + // Create a default material anyway. + material_t material; + InitMaterial(&material); + + // Issue 43. `d` wins against `Tr` since `Tr` is not in the MTL specification. + bool has_d = false; + bool has_tr = false; + + std::stringstream ss; + + std::string linebuf; + while (inStream->peek() != -1) { + safeGetline(*inStream, linebuf); + + // Trim trailing whitespace. + if (linebuf.size() > 0) { + linebuf = linebuf.substr(0, linebuf.find_last_not_of(" \t") + 1); + } + + // Trim newline '\r\n' or '\n' + if (linebuf.size() > 0) { + if (linebuf[linebuf.size() - 1] == '\n') + linebuf.erase(linebuf.size() - 1); + } + if (linebuf.size() > 0) { + if (linebuf[linebuf.size() - 1] == '\r') + linebuf.erase(linebuf.size() - 1); + } + + // Skip if empty line. + if (linebuf.empty()) { + continue; + } + + // Skip leading space. + const char *token = linebuf.c_str(); + token += strspn(token, " \t"); + + assert(token); + if (token[0] == '\0') continue; // empty line + + if (token[0] == '#') continue; // comment line + + // new mtl + if ((0 == strncmp(token, "newmtl", 6)) && IS_SPACE((token[6]))) { + // flush previous material. + if (!material.name.empty()) { + material_map->insert(std::pair( + material.name, static_cast(materials->size()))); + materials->push_back(material); + } + + // initial temporary material + InitMaterial(&material); + + has_d = false; + has_tr = false; + + // set new mtl name + token += 7; + { + std::stringstream sstr; + sstr << token; + material.name = sstr.str(); + } + continue; + } + + // ambient + if (token[0] == 'K' && token[1] == 'a' && IS_SPACE((token[2]))) { + token += 2; + real_t r, g, b; + parseReal3(&r, &g, &b, &token); + material.ambient[0] = r; + material.ambient[1] = g; + material.ambient[2] = b; + continue; + } + + // diffuse + if (token[0] == 'K' && token[1] == 'd' && IS_SPACE((token[2]))) { + token += 2; + real_t r, g, b; + parseReal3(&r, &g, &b, &token); + material.diffuse[0] = r; + material.diffuse[1] = g; + material.diffuse[2] = b; + continue; + } + + // specular + if (token[0] == 'K' && token[1] == 's' && IS_SPACE((token[2]))) { + token += 2; + real_t r, g, b; + parseReal3(&r, &g, &b, &token); + material.specular[0] = r; + material.specular[1] = g; + material.specular[2] = b; + continue; + } + + // transmittance + if ((token[0] == 'K' && token[1] == 't' && IS_SPACE((token[2]))) || + (token[0] == 'T' && token[1] == 'f' && IS_SPACE((token[2])))) { + token += 2; + real_t r, g, b; + parseReal3(&r, &g, &b, &token); + material.transmittance[0] = r; + material.transmittance[1] = g; + material.transmittance[2] = b; + continue; + } + + // ior(index of refraction) + if (token[0] == 'N' && token[1] == 'i' && IS_SPACE((token[2]))) { + token += 2; + material.ior = parseReal(&token); + continue; + } + + // emission + if (token[0] == 'K' && token[1] == 'e' && IS_SPACE(token[2])) { + token += 2; + real_t r, g, b; + parseReal3(&r, &g, &b, &token); + material.emission[0] = r; + material.emission[1] = g; + material.emission[2] = b; + continue; + } + + // shininess + if (token[0] == 'N' && token[1] == 's' && IS_SPACE(token[2])) { + token += 2; + material.shininess = parseReal(&token); + continue; + } + + // illum model + if (0 == strncmp(token, "illum", 5) && IS_SPACE(token[5])) { + token += 6; + material.illum = parseInt(&token); + continue; + } + + // dissolve + if ((token[0] == 'd' && IS_SPACE(token[1]))) { + token += 1; + material.dissolve = parseReal(&token); + + if (has_tr) { + ss << "WARN: Both `d` and `Tr` parameters defined for \"" + << material.name << "\". Use the value of `d` for dissolve." + << std::endl; + } + has_d = true; + continue; + } + if (token[0] == 'T' && token[1] == 'r' && IS_SPACE(token[2])) { + token += 2; + if (has_d) { + // `d` wins. Ignore `Tr` value. + ss << "WARN: Both `d` and `Tr` parameters defined for \"" + << material.name << "\". Use the value of `d` for dissolve." + << std::endl; + } + else { + // We invert value of Tr(assume Tr is in range [0, 1]) + // NOTE: Interpretation of Tr is application(exporter) dependent. For + // some application(e.g. 3ds max obj exporter), Tr = d(Issue 43) + material.dissolve = 1.0f - parseReal(&token); + } + has_tr = true; + continue; + } + + // PBR: roughness + if (token[0] == 'P' && token[1] == 'r' && IS_SPACE(token[2])) { + token += 2; + material.roughness = parseReal(&token); + continue; + } + + // PBR: metallic + if (token[0] == 'P' && token[1] == 'm' && IS_SPACE(token[2])) { + token += 2; + material.metallic = parseReal(&token); + continue; + } + + // PBR: sheen + if (token[0] == 'P' && token[1] == 's' && IS_SPACE(token[2])) { + token += 2; + material.sheen = parseReal(&token); + continue; + } + + // PBR: clearcoat thickness + if (token[0] == 'P' && token[1] == 'c' && IS_SPACE(token[2])) { + token += 2; + material.clearcoat_thickness = parseReal(&token); + continue; + } + + // PBR: clearcoat roughness + if ((0 == strncmp(token, "Pcr", 3)) && IS_SPACE(token[3])) { + token += 4; + material.clearcoat_roughness = parseReal(&token); + continue; + } + + // PBR: anisotropy + if ((0 == strncmp(token, "aniso", 5)) && IS_SPACE(token[5])) { + token += 6; + material.anisotropy = parseReal(&token); + continue; + } + + // PBR: anisotropy rotation + if ((0 == strncmp(token, "anisor", 6)) && IS_SPACE(token[6])) { + token += 7; + material.anisotropy_rotation = parseReal(&token); + continue; + } + + // ambient texture + if ((0 == strncmp(token, "map_Ka", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.ambient_texname), + &(material.ambient_texopt), token, + /* is_bump */ false); + continue; + } + + // diffuse texture + if ((0 == strncmp(token, "map_Kd", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.diffuse_texname), + &(material.diffuse_texopt), token, + /* is_bump */ false); + continue; + } + + // specular texture + if ((0 == strncmp(token, "map_Ks", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.specular_texname), + &(material.specular_texopt), token, + /* is_bump */ false); + continue; + } + + // specular highlight texture + if ((0 == strncmp(token, "map_Ns", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.specular_highlight_texname), + &(material.specular_highlight_texopt), token, + /* is_bump */ false); + continue; + } + + // bump texture + if ((0 == strncmp(token, "map_bump", 8)) && IS_SPACE(token[8])) { + token += 9; + ParseTextureNameAndOption(&(material.bump_texname), + &(material.bump_texopt), token, + /* is_bump */ true); + continue; + } + + // bump texture + if ((0 == strncmp(token, "map_Bump", 8)) && IS_SPACE(token[8])) { + token += 9; + ParseTextureNameAndOption(&(material.bump_texname), + &(material.bump_texopt), token, + /* is_bump */ true); + continue; + } + + // bump texture + if ((0 == strncmp(token, "bump", 4)) && IS_SPACE(token[4])) { + token += 5; + ParseTextureNameAndOption(&(material.bump_texname), + &(material.bump_texopt), token, + /* is_bump */ true); + continue; + } + + // alpha texture + if ((0 == strncmp(token, "map_d", 5)) && IS_SPACE(token[5])) { + token += 6; + material.alpha_texname = token; + ParseTextureNameAndOption(&(material.alpha_texname), + &(material.alpha_texopt), token, + /* is_bump */ false); + continue; + } + + // displacement texture + if ((0 == strncmp(token, "disp", 4)) && IS_SPACE(token[4])) { + token += 5; + ParseTextureNameAndOption(&(material.displacement_texname), + &(material.displacement_texopt), token, + /* is_bump */ false); + continue; + } + + // reflection map + if ((0 == strncmp(token, "refl", 4)) && IS_SPACE(token[4])) { + token += 5; + ParseTextureNameAndOption(&(material.reflection_texname), + &(material.reflection_texopt), token, + /* is_bump */ false); + continue; + } + + // PBR: roughness texture + if ((0 == strncmp(token, "map_Pr", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.roughness_texname), + &(material.roughness_texopt), token, + /* is_bump */ false); + continue; + } + + // PBR: metallic texture + if ((0 == strncmp(token, "map_Pm", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.metallic_texname), + &(material.metallic_texopt), token, + /* is_bump */ false); + continue; + } + + // PBR: sheen texture + if ((0 == strncmp(token, "map_Ps", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.sheen_texname), + &(material.sheen_texopt), token, + /* is_bump */ false); + continue; + } + + // PBR: emissive texture + if ((0 == strncmp(token, "map_Ke", 6)) && IS_SPACE(token[6])) { + token += 7; + ParseTextureNameAndOption(&(material.emissive_texname), + &(material.emissive_texopt), token, + /* is_bump */ false); + continue; + } + + // PBR: normal map texture + if ((0 == strncmp(token, "norm", 4)) && IS_SPACE(token[4])) { + token += 5; + ParseTextureNameAndOption( + &(material.normal_texname), &(material.normal_texopt), token, + /* is_bump */ false); // @fixme { is_bump will be true? } + continue; + } + + // unknown parameter + const char *_space = strchr(token, ' '); + if (!_space) { + _space = strchr(token, '\t'); + } + if (_space) { + std::ptrdiff_t len = _space - token; + std::string key(token, static_cast(len)); + std::string value = _space + 1; + material.unknown_parameter.insert( + std::pair(key, value)); + } + } + // flush last material. + material_map->insert(std::pair( + material.name, static_cast(materials->size()))); + materials->push_back(material); + + if (warning) { + (*warning) = ss.str(); + } + } + + bool MaterialFileReader::operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, + std::string *err) { + std::string filepath; + + if (!m_mtlBaseDir.empty()) { + filepath = std::string(m_mtlBaseDir) + matId; + } + else { + filepath = matId; + } + + std::ifstream matIStream(filepath.c_str()); + if (!matIStream) { + std::stringstream ss; + ss << "WARN: Material file [ " << filepath << " ] not found." << std::endl; + if (err) { + (*err) += ss.str(); + } + return false; + } + + std::string warning; + LoadMtl(matMap, materials, &matIStream, &warning); + + if (!warning.empty()) { + if (err) { + (*err) += warning; + } + } + + return true; + } + + bool MaterialStreamReader::operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, + std::string *err) { + (void)matId; + if (!m_inStream) { + std::stringstream ss; + ss << "WARN: Material stream in error state. " << std::endl; + if (err) { + (*err) += ss.str(); + } + return false; + } + + std::string warning; + LoadMtl(matMap, materials, &m_inStream, &warning); + + if (!warning.empty()) { + if (err) { + (*err) += warning; + } + } + + return true; + } + + bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *err, + const char *filename, const char *mtl_basedir, bool trianglulate) { + attrib->vertices.clear(); + attrib->normals.clear(); + attrib->texcoords.clear(); + attrib->colors.clear(); + shapes->clear(); + + std::stringstream errss; + + std::ifstream ifs(filename); + if (!ifs) { + errss << "Cannot open file [" << filename << "]" << std::endl; + if (err) { + (*err) = errss.str(); + } + return false; + } + + std::string baseDir; + if (mtl_basedir) { + baseDir = mtl_basedir; + } + MaterialFileReader matFileReader(baseDir); + + return LoadObj(attrib, shapes, materials, err, &ifs, &matFileReader, + trianglulate); + } + + bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *err, + std::istream *inStream, MaterialReader *readMatFn /*= NULL*/, + bool triangulate) { + std::stringstream errss; + + std::vector v; + std::vector vn; + std::vector vt; + std::vector vc; + std::vector tags; + std::vector > faceGroup; + std::string name; + + // material + std::map material_map; + int material = -1; + + shape_t shape; + + std::string linebuf; + while (inStream->peek() != -1) { + safeGetline(*inStream, linebuf); + + // Trim newline '\r\n' or '\n' + if (linebuf.size() > 0) { + if (linebuf[linebuf.size() - 1] == '\n') + linebuf.erase(linebuf.size() - 1); + } + if (linebuf.size() > 0) { + if (linebuf[linebuf.size() - 1] == '\r') + linebuf.erase(linebuf.size() - 1); + } + + // Skip if empty line. + if (linebuf.empty()) { + continue; + } + + // Skip leading space. + const char *token = linebuf.c_str(); + token += strspn(token, " \t"); + + assert(token); + if (token[0] == '\0') continue; // empty line + + if (token[0] == '#') continue; // comment line + + // vertex + if (token[0] == 'v' && IS_SPACE((token[1]))) { + token += 2; + real_t x, y, z; + real_t r, g, b; + parseVertexWithColor(&x, &y, &z, &r, &g, &b, &token); + v.push_back(x); + v.push_back(y); + v.push_back(z); + + vc.push_back(r); + vc.push_back(g); + vc.push_back(b); + continue; + } + + // normal + if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) { + token += 3; + real_t x, y, z; + parseReal3(&x, &y, &z, &token); + vn.push_back(x); + vn.push_back(y); + vn.push_back(z); + continue; + } + + // texcoord + if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) { + token += 3; + real_t x, y; + parseReal2(&x, &y, &token); + vt.push_back(x); + vt.push_back(y); + continue; + } + + // face + if (token[0] == 'f' && IS_SPACE((token[1]))) { + token += 2; + token += strspn(token, " \t"); + + std::vector face; + face.reserve(3); + + while (!IS_NEW_LINE(token[0])) { + vertex_index vi; + if (!parseTriple(&token, static_cast(v.size() / 3), + static_cast(vn.size() / 3), + static_cast(vt.size() / 2), &vi)) { + if (err) { + (*err) = "Failed parse `f' line(e.g. zero value for face index).\n"; + } + return false; + } + + face.push_back(vi); + size_t n = strspn(token, " \t\r"); + token += n; + } + + // replace with emplace_back + std::move on C++11 + faceGroup.push_back(std::vector()); + faceGroup[faceGroup.size() - 1].swap(face); + + continue; + } + + // use mtl + if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) { + token += 7; + std::stringstream ss; + ss << token; + std::string namebuf = ss.str(); + + int newMaterialId = -1; + if (material_map.find(namebuf) != material_map.end()) { + newMaterialId = material_map[namebuf]; + } + else { + // { error!! material not found } + } + + if (newMaterialId != material) { + // Create per-face material. Thus we don't add `shape` to `shapes` at + // this time. + // just clear `faceGroup` after `exportFaceGroupToShape()` call. + exportFaceGroupToShape(&shape, faceGroup, tags, material, name, + triangulate); + faceGroup.clear(); + material = newMaterialId; + } + + continue; + } + + // load mtl + if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) { + if (readMatFn) { + token += 7; + + std::vector filenames; + SplitString(std::string(token), ' ', filenames); + + if (filenames.empty()) { + if (err) { + (*err) += + "WARN: Looks like empty filename for mtllib. Use default " + "material. \n"; + } + } + else { + bool found = false; + for (size_t s = 0; s < filenames.size(); s++) { + std::string err_mtl; + bool ok = (*readMatFn)(filenames[s].c_str(), materials, + &material_map, &err_mtl); + if (err && (!err_mtl.empty())) { + (*err) += err_mtl; // This should be warn message. + } + + if (ok) { + found = true; + break; + } + } + + if (!found) { + if (err) { + (*err) += + "WARN: Failed to load material file(s). Use default " + "material.\n"; + } + } + } + } + + continue; + } + + // group name + if (token[0] == 'g' && IS_SPACE((token[1]))) { + // flush previous face group. + bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name, + triangulate); + (void)ret; // return value not used. + + if (shape.mesh.indices.size() > 0) { + shapes->push_back(shape); + } + + shape = shape_t(); + + // material = -1; + faceGroup.clear(); + + std::vector names; + names.reserve(2); + + while (!IS_NEW_LINE(token[0])) { + std::string str = parseString(&token); + names.push_back(str); + token += strspn(token, " \t\r"); // skip tag + } + + assert(names.size() > 0); + + // names[0] must be 'g', so skip the 0th element. + if (names.size() > 1) { + name = names[1]; + } + else { + name = ""; + } + + continue; + } + + // object name + if (token[0] == 'o' && IS_SPACE((token[1]))) { + // flush previous face group. + bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name, + triangulate); + if (ret) { + shapes->push_back(shape); + } + + // material = -1; + faceGroup.clear(); + shape = shape_t(); + + // @todo { multiple object name? } + token += 2; + std::stringstream ss; + ss << token; + name = ss.str(); + + continue; + } + + if (token[0] == 't' && IS_SPACE(token[1])) { + tag_t tag; + + token += 2; + + tag.name = parseString(&token); + + tag_sizes ts = parseTagTriple(&token); + + tag.intValues.resize(static_cast(ts.num_ints)); + + for (size_t i = 0; i < static_cast(ts.num_ints); ++i) { + tag.intValues[i] = parseInt(&token); + } + + tag.floatValues.resize(static_cast(ts.num_reals)); + for (size_t i = 0; i < static_cast(ts.num_reals); ++i) { + tag.floatValues[i] = parseReal(&token); + } + + tag.stringValues.resize(static_cast(ts.num_strings)); + for (size_t i = 0; i < static_cast(ts.num_strings); ++i) { + tag.stringValues[i] = parseString(&token); + } + + tags.push_back(tag); + } + + // Ignore unknown command. + } + + bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name, + triangulate); + // exportFaceGroupToShape return false when `usemtl` is called in the last + // line. + // we also add `shape` to `shapes` when `shape.mesh` has already some + // faces(indices) + if (ret || shape.mesh.indices.size()) { + shapes->push_back(shape); + } + faceGroup.clear(); // for safety + + if (err) { + (*err) += errss.str(); + } + + attrib->vertices.swap(v); + attrib->normals.swap(vn); + attrib->texcoords.swap(vt); + attrib->colors.swap(vc); + + return true; + } + + bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback, + void *user_data /*= NULL*/, + MaterialReader *readMatFn /*= NULL*/, + std::string *err /*= NULL*/) { + std::stringstream errss; + + // material + std::map material_map; + int material_id = -1; // -1 = invalid + + std::vector indices; + std::vector materials; + std::vector names; + names.reserve(2); + std::string name; + std::vector names_out; + + std::string linebuf; + while (inStream.peek() != -1) { + safeGetline(inStream, linebuf); + + // Trim newline '\r\n' or '\n' + if (linebuf.size() > 0) { + if (linebuf[linebuf.size() - 1] == '\n') + linebuf.erase(linebuf.size() - 1); + } + if (linebuf.size() > 0) { + if (linebuf[linebuf.size() - 1] == '\r') + linebuf.erase(linebuf.size() - 1); + } + + // Skip if empty line. + if (linebuf.empty()) { + continue; + } + + // Skip leading space. + const char *token = linebuf.c_str(); + token += strspn(token, " \t"); + + assert(token); + if (token[0] == '\0') continue; // empty line + + if (token[0] == '#') continue; // comment line + + // vertex + if (token[0] == 'v' && IS_SPACE((token[1]))) { + token += 2; + // TODO(syoyo): Support parsing vertex color extension. + real_t x, y, z, w; // w is optional. default = 1.0 + parseV(&x, &y, &z, &w, &token); + if (callback.vertex_cb) { + callback.vertex_cb(user_data, x, y, z, w); + } + continue; + } + + // normal + if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) { + token += 3; + real_t x, y, z; + parseReal3(&x, &y, &z, &token); + if (callback.normal_cb) { + callback.normal_cb(user_data, x, y, z); + } + continue; + } + + // texcoord + if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) { + token += 3; + real_t x, y, z; // y and z are optional. default = 0.0 + parseReal3(&x, &y, &z, &token); + if (callback.texcoord_cb) { + callback.texcoord_cb(user_data, x, y, z); + } + continue; + } + + // face + if (token[0] == 'f' && IS_SPACE((token[1]))) { + token += 2; + token += strspn(token, " \t"); + + indices.clear(); + while (!IS_NEW_LINE(token[0])) { + vertex_index vi = parseRawTriple(&token); + + index_t idx; + idx.vertex_index = vi.v_idx; + idx.normal_index = vi.vn_idx; + idx.texcoord_index = vi.vt_idx; + + indices.push_back(idx); + size_t n = strspn(token, " \t\r"); + token += n; + } + + if (callback.index_cb && indices.size() > 0) { + callback.index_cb(user_data, &indices.at(0), + static_cast(indices.size())); + } + + continue; + } + + // use mtl + if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) { + token += 7; + std::stringstream ss; + ss << token; + std::string namebuf = ss.str(); + + int newMaterialId = -1; + if (material_map.find(namebuf) != material_map.end()) { + newMaterialId = material_map[namebuf]; + } + else { + // { error!! material not found } + } + + if (newMaterialId != material_id) { + material_id = newMaterialId; + } + + if (callback.usemtl_cb) { + callback.usemtl_cb(user_data, namebuf.c_str(), material_id); + } + + continue; + } + + // load mtl + if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) { + if (readMatFn) { + token += 7; + + std::vector filenames; + SplitString(std::string(token), ' ', filenames); + + if (filenames.empty()) { + if (err) { + (*err) += + "WARN: Looks like empty filename for mtllib. Use default " + "material. \n"; + } + } + else { + bool found = false; + for (size_t s = 0; s < filenames.size(); s++) { + std::string err_mtl; + bool ok = (*readMatFn)(filenames[s].c_str(), &materials, + &material_map, &err_mtl); + if (err && (!err_mtl.empty())) { + (*err) += err_mtl; // This should be warn message. + } + + if (ok) { + found = true; + break; + } + } + + if (!found) { + if (err) { + (*err) += + "WARN: Failed to load material file(s). Use default " + "material.\n"; + } + } + else { + if (callback.mtllib_cb) { + callback.mtllib_cb(user_data, &materials.at(0), + static_cast(materials.size())); + } + } + } + } + + continue; + } + + // group name + if (token[0] == 'g' && IS_SPACE((token[1]))) { + names.clear(); + + while (!IS_NEW_LINE(token[0])) { + std::string str = parseString(&token); + names.push_back(str); + token += strspn(token, " \t\r"); // skip tag + } + + assert(names.size() > 0); + + // names[0] must be 'g', so skip the 0th element. + if (names.size() > 1) { + name = names[1]; + } + else { + name.clear(); + } + + if (callback.group_cb) { + if (names.size() > 1) { + // create const char* array. + names_out.resize(names.size() - 1); + for (size_t j = 0; j < names_out.size(); j++) { + names_out[j] = names[j + 1].c_str(); + } + callback.group_cb(user_data, &names_out.at(0), + static_cast(names_out.size())); + + } + else { + callback.group_cb(user_data, NULL, 0); + } + } + + continue; + } + + // object name + if (token[0] == 'o' && IS_SPACE((token[1]))) { + // @todo { multiple object name? } + token += 2; + + std::stringstream ss; + ss << token; + std::string object_name = ss.str(); + + if (callback.object_cb) { + callback.object_cb(user_data, object_name.c_str()); + } + + continue; + } + +#if 0 // @todo + if (token[0] == 't' && IS_SPACE(token[1])) { + tag_t tag; + token += 2; + std::stringstream ss; + ss << token; + tag.name = ss.str(); + token += tag.name.size() + 1; + tag_sizes ts = parseTagTriple(&token); + tag.intValues.resize(static_cast(ts.num_ints)); + for (size_t i = 0; i < static_cast(ts.num_ints); ++i) { + tag.intValues[i] = atoi(token); + token += strcspn(token, "/ \t\r") + 1; + } + tag.floatValues.resize(static_cast(ts.num_reals)); + for (size_t i = 0; i < static_cast(ts.num_reals); ++i) { + tag.floatValues[i] = parseReal(&token); + token += strcspn(token, "/ \t\r") + 1; + } + tag.stringValues.resize(static_cast(ts.num_strings)); + for (size_t i = 0; i < static_cast(ts.num_strings); ++i) { + std::stringstream ss; + ss << token; + tag.stringValues[i] = ss.str(); + token += tag.stringValues[i].size() + 1; + } + tags.push_back(tag); + } +#endif + + // Ignore unknown command. + } + + if (err) { + (*err) += errss.str(); + } + + return true; + } +} // namespace tinyobj + +#endif \ No newline at end of file