diff --git a/.gitignore b/.gitignore index 89942d9..32e5d12 100644 --- a/.gitignore +++ b/.gitignore @@ -558,3 +558,5 @@ xcuserdata *.xccheckout *.moved-aside *.xcuserstate + +build-8.0/ \ No newline at end of file diff --git a/README.md b/README.md index 110697c..54de44f 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,86 @@ +![445000 spp, 11 hours](img/joseph_suzie_445000.png) + CUDA Path Tracer ================ **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) +* Alexander Chan +* Tested on: Windows 10 Version 1803, i7-5820k @ 3.70 GHz 16GB, GTX 1080 @ 1620 MHz 8GB (Personal Computer) + +Click on the images for full resolution. + +## Summary +A physically based pathtracer written in CUDA. Supports the following: +* Diffuse and perfectly specular reflective materials +* Refractive materials with controllable dispersion +* .obj loading for meshes +* Scene kd-tree with SAH for acceleration +* Texture mapping +* Normal mapping +* Antialiasing +* Stream compaction for early terminating rays + +## Features + +#### Refraction with Fresnel +Refractive materials are with Fresnel. The proportion of reflected and refracted light is computed using the actual Fresnel equations. A random number from 0 to 1 is generated, and if it is less than the proportion of reflected light, the ray is scattered via specular reflection, otherwise it is scattered via refraction. See the [textures](#textures) section as well as the [final](#more-renders) section for renders. + +#### Dispersion +In real life, light of different wavelengths are refracted by different amounts. A classic example is a prism, where white light is split up into a rainbow, because the longer wavelengths of light (red) are bent less than shorter wavelengths of light (blue). Here's the same scene rendered with and without dispersion. All the materials used are colorless, and all the color comes from dispersion. + +| Dispersion = 0 | Dispersion = 0.44 | +|---------------|------------------| +|![](img/nodisp.png) | ![](img/disp.png)| + +The banner image at the top was rendered with 45000 samples and took 12 hours. The two images above are at 7500 samples and took approximately 2 hours each. + +Here's a comparison of different dispersion coefficients. Each of these renders are at 6000 samples and rendered in approximately one hour. + +| Dispersion = 0 | Dispersion = 0.1 | +|:-:|:-:| +|![](img/specular_refraction_dragon_disp0.png)|![](img/specular_refraction_dragon_disp.1.png)| +| **Dispersion = 0.5** | **Dispersion = 1** | +|![](img/specular_refraction_dragon_disp.5.png)|![](img/specular_refraction_dragon_disp1.png)| + +Colored refractive materials can also be dispersive. Here's a comparison of clear dispersive and non dispersive dragons as well as yellow dispersive and non dispersive dragons. + +|![](img/specular_refraction_dragon_disp0.png)|![](img/specular_refraction_dragon_disp.5.png)| +|:-:|:-:| +|![](img/specular_refraction_dragon_yellow_disp0.png)|![](img/specular_refraction_dragon_yellow_disp.5.png)| + +Dispersion does not cause each iteration to take more time, but rendering with a high dispersion may take more iterations to reach the same level of convergence. + +#### Meshes +Mesh rendering is implemented using a triangle geometry. When a mesh is loaded via tinyobj, its vertex positions, normals, and uv coordinates are assembled into Geoms. Because of the large number of triangles that even simple meshes may have, rendering a scene containing a mesh without the use of an acceleration structure is incredibly slow. + +#### Acceleration structure +To render large amounts of geometry, like those present in meshes, a kd-tree is used to accelerate ray intersection testing. After the scene is loaded, a kd-tree is built on the CPU, using either the split method by median of longest axis, or the surface area heuristic. Performance comparison for these two heuristics follow. The kd-tree is flattened on the CPU, then copied to the GPU. Traversal on the GPU uses a stack. As kd-tree nodes in the flattened tree can contain variable amounts of geometry, each node contains an index into a geometry array. This geometry array is sorted so that all the primitives in the same node are contiguous in memory. Much of the implementation is based on PBRT and previous code written for a raytracer and a CPU pathtracer. + +![](img/kdtree-performance.png) + +The surface area heuristic is about 32 times faster on a 5000 primitive scene (Stanford bunny). On a 100k primitive scene (Stanford dragon), the SAH method was a little more than twice as slow as the 5000 prim scene, and the median split method didn't even finish one iteration (rendering with no acceleration structure wasn't tested, as one iteration never finished even for the 5000 primitive scene). Having some acceleration structure is better than none, but having a good split heuristic while constructing the tree makes a big difference. + +#### Textures +Diffuse textures and normal maps are supported using the `TEX` and `NOR` attributes when defining materials. As textures are loaded, their data is added onto a flat array containing every texture. Each material stores an offset to the array to where its texture starts, along with the texture width to correctly compute the location in the array of a given pixel. Both normal maps and diffuse textures are stored in the same array. UV mapping is implemented for cubes, spheres, and meshes. + +|![](img/textures.png)|![](img/textures-alt.png)| +|---------------|------------------| +|![](img/normal.png)|![](img/mesh_texture.png)| + + +#### Antialiasing +First rays emitted from the camera are uniformly jittered within each pixel so that each first bounce is not the same. -### (TODO: Your README) +## More renders +Finally, here are more renders to show correctness. Note that I turned up the emittance of the light to 8 from 5, so these may look brighter than reference renders. -*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. +|![](img/diffuse_blue_dragon.png)|![](img/specular_reflection_dragon.png)| +|---------------|------------------| +|![](img/specular_refraction_dragon_disp0.png)|![](img/specular_refraction_dragon_blue.png)| +|![](img/vanilla_1.png)|![](img/vanilla_specular.png)| +## References +* tinyobj loader +* PBRT v3 +* Emily Vo (Dispersion) \ No newline at end of file diff --git a/img/diffuse_blue_dragon.png b/img/diffuse_blue_dragon.png new file mode 100644 index 0000000..12a03ed Binary files /dev/null and b/img/diffuse_blue_dragon.png differ diff --git a/img/disp.png b/img/disp.png new file mode 100644 index 0000000..c99d8ed Binary files /dev/null and b/img/disp.png differ diff --git a/img/joseph_suzie_445000.png b/img/joseph_suzie_445000.png new file mode 100644 index 0000000..53fa2ef Binary files /dev/null and b/img/joseph_suzie_445000.png differ diff --git a/img/kdtree-performance.png b/img/kdtree-performance.png new file mode 100644 index 0000000..445ae20 Binary files /dev/null and b/img/kdtree-performance.png differ diff --git a/img/mesh_texture.png b/img/mesh_texture.png new file mode 100644 index 0000000..bcb9c91 Binary files /dev/null and b/img/mesh_texture.png differ diff --git a/img/nodisp.png b/img/nodisp.png new file mode 100644 index 0000000..896958b Binary files /dev/null and b/img/nodisp.png differ diff --git a/img/normal.png b/img/normal.png new file mode 100644 index 0000000..35504f4 Binary files /dev/null and b/img/normal.png differ diff --git a/img/specular_reflection.15000.5min.png b/img/specular_reflection.15000.5min.png new file mode 100644 index 0000000..919d0a6 Binary files /dev/null and b/img/specular_reflection.15000.5min.png differ diff --git a/img/specular_reflection_dragon.png b/img/specular_reflection_dragon.png new file mode 100644 index 0000000..cf12e21 Binary files /dev/null and b/img/specular_reflection_dragon.png differ diff --git a/img/specular_refraction_dragon_blue.png b/img/specular_refraction_dragon_blue.png new file mode 100644 index 0000000..165d238 Binary files /dev/null and b/img/specular_refraction_dragon_blue.png differ diff --git a/img/specular_refraction_dragon_disp.1.png b/img/specular_refraction_dragon_disp.1.png new file mode 100644 index 0000000..01589e2 Binary files /dev/null and b/img/specular_refraction_dragon_disp.1.png differ diff --git a/img/specular_refraction_dragon_disp.5.png b/img/specular_refraction_dragon_disp.5.png new file mode 100644 index 0000000..4b07623 Binary files /dev/null and b/img/specular_refraction_dragon_disp.5.png differ diff --git a/img/specular_refraction_dragon_disp0.png b/img/specular_refraction_dragon_disp0.png new file mode 100644 index 0000000..db12ac8 Binary files /dev/null and b/img/specular_refraction_dragon_disp0.png differ diff --git a/img/specular_refraction_dragon_disp1.png b/img/specular_refraction_dragon_disp1.png new file mode 100644 index 0000000..0af3a88 Binary files /dev/null and b/img/specular_refraction_dragon_disp1.png differ diff --git a/img/specular_refraction_dragon_yellow_disp.5.png b/img/specular_refraction_dragon_yellow_disp.5.png new file mode 100644 index 0000000..3bad2f0 Binary files /dev/null and b/img/specular_refraction_dragon_yellow_disp.5.png differ diff --git a/img/specular_refraction_dragon_yellow_disp0.png b/img/specular_refraction_dragon_yellow_disp0.png new file mode 100644 index 0000000..e8f6258 Binary files /dev/null and b/img/specular_refraction_dragon_yellow_disp0.png differ diff --git a/img/textures-alt.png b/img/textures-alt.png new file mode 100644 index 0000000..b9cbce2 Binary files /dev/null and b/img/textures-alt.png differ diff --git a/img/textures.png b/img/textures.png new file mode 100644 index 0000000..f785de9 Binary files /dev/null and b/img/textures.png differ diff --git a/img/vanilla_1.png b/img/vanilla_1.png new file mode 100644 index 0000000..d5ecac3 Binary files /dev/null and b/img/vanilla_1.png differ diff --git a/img/vanilla_specular.png b/img/vanilla_specular.png new file mode 100644 index 0000000..9e79acc Binary files /dev/null and b/img/vanilla_specular.png differ diff --git a/scenes/2tex-test.txt b/scenes/2tex-test.txt new file mode 100644 index 0000000..dfcf12b --- /dev/null +++ b/scenes/2tex-test.txt @@ -0,0 +1,179 @@ +// Emissive material (light) +MATERIAL 0 +RGB 1 1 1 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 8 +TEX NONE +NOR NONE + +// Diffuse white +MATERIAL 1 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffuse red +MATERIAL 2 +RGB .85 .35 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffuse green +MATERIAL 3 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Specular white +MATERIAL 4 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffraction +MATERIAL 5 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Checkerboard +MATERIAL 6 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png +NOR NONE + +// Grid +MATERIAL 7 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/grid.jpg +NOR NONE + +// Camera +CAMERA +RES 800 800 +FOVY 45 +ITERATIONS 50000 +DEPTH 8 +FILE cornell +EYE 0.0 5 10.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 3 .3 3 + +// Floor +OBJECT 1 +cube +material 6 +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 7 +TRANS 0 5 -5 +ROTAT 0 90 0 +SCALE .01 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 5 +TRANS 0 4 1 +ROTAT 0 0 0 +SCALE 4 4 4 + +// TEST MESH +OBJECT 7 +sphere +material 6 +TRANS 1 4 -2 +ROTAT 0 0 0 +SCALE 2 2 2 \ No newline at end of file diff --git a/scenes/cornell-base.txt b/scenes/cornell-base.txt new file mode 100644 index 0000000..8825a4c --- /dev/null +++ b/scenes/cornell-base.txt @@ -0,0 +1,171 @@ +// Emissive material (light) +MATERIAL 0 +RGB 1 1 1 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 8 +TEX NONE + +// Diffuse white +MATERIAL 1 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE + +// Diffuse red +MATERIAL 2 +RGB .85 .35 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE + +// Diffuse green +MATERIAL 3 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE + +// Specular white +MATERIAL 4 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE + +// Dispersion +MATERIAL 5 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP .44 +EMITTANCE 0 +TEX NONE + +// Checkerboard Texture +MATERIAL 6 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png + +// Grid Texture +MATERIAL 7 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/grid.jpg + +// Camera +CAMERA +RES 800 800 +FOVY 45 +ITERATIONS 50000 +DEPTH 8 +FILE cornell +EYE 0.0 5 10.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 3 .3 3 + +// Floor +OBJECT 1 +cube +material 6 +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 .01 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 + +// dragon +OBJECT 6 +mesh ../scenes/models/dragon.obj +material 5 +TRANS 0 0 -1 +ROTAT 0 15 0 +SCALE .6 .6 .6 + +// bunny +OBJECT 7 +mesh ../scenes/models/bunny.obj +material 5 +TRANS 3 0 2 +ROTAT 0 -15 0 +SCALE .6 .6 .6 \ No newline at end of file diff --git a/scenes/cornell.txt b/scenes/cornell.txt index 83ff820..ab24f78 100644 --- a/scenes/cornell.txt +++ b/scenes/cornell.txt @@ -6,7 +6,10 @@ SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 -EMITTANCE 5 +DISP 0 +EMITTANCE 8 +TEX NONE +NOR NONE // Diffuse white MATERIAL 1 @@ -16,7 +19,10 @@ SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 +DISP 0 EMITTANCE 0 +TEX NONE +NOR NONE // Diffuse red MATERIAL 2 @@ -26,7 +32,10 @@ SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 +DISP 0 EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png +NOR NONE // Diffuse green MATERIAL 3 @@ -36,26 +45,84 @@ SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 +DISP 0 EMITTANCE 0 +TEX NONE +NOR NONE // Specular white MATERIAL 4 +RGB .95 .87 .35 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffraction +MATERIAL 5 RGB .98 .98 .98 SPECEX 0 SPECRGB .98 .98 .98 REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Checkerboard +MATERIAL 6 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png +NOR NONE + +// Grid +MATERIAL 7 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/grid.jpg +NOR NONE + +// Diffuse Blue +MATERIAL 8 +RGB .46 .65 .95 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 REFR 0 REFRIOR 0 +DISP 0 EMITTANCE 0 +TEX NONE +NOR NONE // Camera CAMERA RES 800 800 FOVY 45 -ITERATIONS 5000 +ITERATIONS 6000 DEPTH 8 FILE cornell -EYE 0.0 5 10.5 +EYE 0.0 5 10 LOOKAT 0 5 0 UP 0 1 0 @@ -110,8 +177,8 @@ SCALE .01 10 10 // Sphere OBJECT 6 -sphere +mesh ../scenes/models/dragon.obj material 4 -TRANS -1 4 -1 -ROTAT 0 0 0 -SCALE 3 3 3 +TRANS 0 0 0 +ROTAT 0 15 0 +SCALE .7 .7 .7 diff --git a/scenes/dragon-bunny-disp.txt b/scenes/dragon-bunny-disp.txt new file mode 100644 index 0000000..83ac5cc --- /dev/null +++ b/scenes/dragon-bunny-disp.txt @@ -0,0 +1,191 @@ +// Emissive material (light) +MATERIAL 0 +RGB 1 1 1 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 8 +TEX NONE +NOR NONE + +// Diffuse white +MATERIAL 1 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffuse red +MATERIAL 2 +RGB .85 .35 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffuse green +MATERIAL 3 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Specular white +MATERIAL 4 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Dispersion +MATERIAL 5 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0.44 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Checkerboard Texture +MATERIAL 6 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png +NOR NONE + +// Grid Texture +MATERIAL 7 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/grid.jpg +NOR NONE + +// Camera +CAMERA +RES 1920 810 +FOVY 45 +ITERATIONS 50000 +DEPTH 8 +FILE cornell +EYE 0.0 -1 8.5 +LOOKAT 0 4 0 +UP 0 1 0 + + +// Ceiling light +OBJECT 0 +cube +material 0 +TRANS -10 10 0 +ROTAT 0 0 0 +SCALE 3 .3 3 + +OBJECT 0 +cube +material 0 +TRANS 10 10 0 +ROTAT 0 0 0 +SCALE 3 .3 3 + +OBJECT 0 +cube +material 0 +TRANS 0 10 0 +ROTAT 0 0 0 +SCALE 3 .3 3 + +// Floor +OBJECT 1 +cube +material 1 +TRANS 0 0 0 +ROTAT 0 0 0 +SCALE 100 .01 15 + +// Ceiling +OBJECT 2 +cube +material 1 +TRANS 0 10 0 +ROTAT 0 0 90 +SCALE .01 40 10 + +// Back wall +OBJECT 3 +cube +material 1 +TRANS 0 5 -5 +ROTAT 0 90 0 +SCALE .01 10 100 + +// OBJECT 5 +// cube +// material 1 +// TRANS 10 0 0 +// ROTAT 0 0 0 +// SCALE 10 .01 10 + +// OBJECT 5 +// cube +// material 1 +// TRANS -10 0 0 +// ROTAT 0 0 0 +// SCALE 10 .01 10 + +// dragon +OBJECT 6 +mesh ../scenes/models/dragon.obj +material 5 +TRANS -3 0 -1 +ROTAT 0 15 0 +SCALE .9 .9 .9 + +// bunny +OBJECT 7 +mesh ../scenes/models/bunny.obj +material 5 +TRANS 4 0 3 +ROTAT 0 -15 0 +SCALE .9. .9 .9 \ No newline at end of file diff --git a/scenes/dragon-cornell.txt b/scenes/dragon-cornell.txt new file mode 100644 index 0000000..6efb97c --- /dev/null +++ b/scenes/dragon-cornell.txt @@ -0,0 +1,184 @@ +// Emissive material (light) +MATERIAL 0 +RGB 1 1 1 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 8 +TEX NONE +NOR NONE + +// Diffuse white +MATERIAL 1 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffuse red +MATERIAL 2 +RGB .85 .35 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png +NOR NONE + +// Diffuse green +MATERIAL 3 +RGB .35 .85 .35 +SPECEX 0 +SPECRGB 0 0 0 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Specular white +MATERIAL 4 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0.5 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Diffraction +MATERIAL 5 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 1 +REFR 1 +REFRIOR 1.3 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Checkerboard +MATERIAL 6 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/checkerboard.png +NOR NONE + +// Grid +MATERIAL 7 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX ../scenes/textures/grid.jpg +NOR NONE + +// Diffuse Blue +MATERIAL 8 +RGB .46 .65 .95 +SPECEX 0 +SPECRGB .98 .98 .98 +REFL 0 +REFR 0 +REFRIOR 0 +DISP 0 +EMITTANCE 0 +TEX NONE +NOR NONE + +// Camera +CAMERA +RES 800 800 +FOVY 45 +ITERATIONS 6000 +DEPTH 8 +FILE cornell +EYE 0.0 5 10.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 3 .3 3 + +// 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 .01 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 +mesh ../scenes/models/bunny.obj +material 4 +TRANS 0 0 0 +ROTAT 0 15 0 +SCALE .7 .7 .7 diff --git a/scenes/models/bunny.mtl b/scenes/models/bunny.mtl new file mode 100644 index 0000000..c89145d --- /dev/null +++ b/scenes/models/bunny.mtl @@ -0,0 +1,6 @@ +newmtl initialShadingGroup +illum 4 +Kd 0.50 0.50 0.50 +Ka 0.00 0.00 0.00 +Tf 1.00 1.00 1.00 +Ni 1.00 diff --git a/scenes/textures/.mayaSwatches/bussy.png_hcm.swatch b/scenes/textures/.mayaSwatches/bussy.png_hcm.swatch new file mode 100644 index 0000000..d67dd5a Binary files /dev/null and b/scenes/textures/.mayaSwatches/bussy.png_hcm.swatch differ diff --git a/scenes/textures/brick_norm.jpg b/scenes/textures/brick_norm.jpg new file mode 100644 index 0000000..19f48f4 Binary files /dev/null and b/scenes/textures/brick_norm.jpg differ diff --git a/scenes/textures/checkerboard.png b/scenes/textures/checkerboard.png new file mode 100644 index 0000000..0dfabce Binary files /dev/null and b/scenes/textures/checkerboard.png differ diff --git a/scenes/textures/grid.jpg b/scenes/textures/grid.jpg new file mode 100644 index 0000000..1cd2298 Binary files /dev/null and b/scenes/textures/grid.jpg differ diff --git a/scenes/textures/wahoo.bmp b/scenes/textures/wahoo.bmp new file mode 100644 index 0000000..bf1598d Binary files /dev/null and b/scenes/textures/wahoo.bmp differ diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index a1cb3fb..4bd7f4b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -15,9 +15,12 @@ set(SOURCE_FILES "preview.cpp" "utilities.cpp" "utilities.h" + "tiny_obj_loader.h" + "tiny_obj_loader.cc" + "defines.h" ) cuda_add_library(src ${SOURCE_FILES} - OPTIONS -arch=sm_20 + OPTIONS -arch=sm_61 ) diff --git a/src/defines.h b/src/defines.h new file mode 100644 index 0000000..fc96f34 --- /dev/null +++ b/src/defines.h @@ -0,0 +1,8 @@ +#pragma once + +#define KDTREE 1 +#define N_BUCKETS 12 + +#define SPLIT_SAH 1 + +#define STREAM_COMPACT 0 \ No newline at end of file diff --git a/src/interactions.h b/src/interactions.h index 5ce3628..6c63151 100644 --- a/src/interactions.h +++ b/src/interactions.h @@ -41,6 +41,90 @@ glm::vec3 calculateRandomDirectionInHemisphere( + sin(around) * over * perpendicularDirection2; } +__forceinline__ +__host__ __device__ +bool Refract(const glm::vec3 &wi, const glm::vec3 &n, float eta, + glm::vec3 *wt) { + // Compute cos theta using Snell's law + float cosThetaI = glm::dot(n, wi); + float sin2ThetaI = glm::max(float(0), float(1 - cosThetaI * cosThetaI)); + float sin2ThetaT = eta * eta * sin2ThetaI; + + // Handle total internal reflection for transmission + if (sin2ThetaT >= 1) return false; + float cosThetaT = glm::sqrt(1 - sin2ThetaT); + *wt = eta * -wi + (eta * cosThetaI - cosThetaT) * glm::vec3(n); + return true; +} + +__forceinline__ +__host__ __device__ +void SpecularBTDF(PathSegment & pathSegment, glm::vec3 intersect, + glm::vec3 normal, const Material &m, thrust::default_random_engine &rng) { + thrust::uniform_real_distribution u01(0, 1); + + glm::vec3 wo = -pathSegment.ray.direction; + float VdotN = glm::dot(wo, normal); + bool leaving = VdotN < 0.f; + glm::vec3 n = normal * (leaving ? -1.f : 1.f); + float eta = leaving ? m.indexOfRefraction : (1.f / m.indexOfRefraction); + float d = m.dispersion; + Refract(wo, n, eta, &pathSegment.ray.direction); + pathSegment.ray.origin = intersect + (.001f) * pathSegment.ray.direction; + pathSegment.color *= m.color; +} + +__forceinline__ +__host__ __device__ +void LambertBRDF(PathSegment &pathSegment, glm::vec3 intersect, + glm::vec3 normal, const Material &m, thrust::default_random_engine &rng) { + pathSegment.ray.direction = calculateRandomDirectionInHemisphere(glm::normalize(normal), rng); + glm::vec3 f = m.color * INV_PI; + float absDot = glm::abs(glm::dot(glm::normalize(-pathSegment.ray.direction), normal)); + float pdf = absDot * INV_PI; + pathSegment.color *= f * absDot / pdf; + pathSegment.ray.origin = intersect + (.0001f) * pathSegment.ray.direction; +} + +__forceinline__ +__host__ __device__ +void SpecularBRDF(PathSegment &pathSegment, glm::vec3 intersect, + glm::vec3 normal, const Material &m, thrust::default_random_engine &rng) { + pathSegment.ray.direction = glm::reflect(pathSegment.ray.direction, normal); + glm::vec3 f = m.specular.color; + float pdf = 1.f; + pathSegment.color *= f; + pathSegment.ray.origin = intersect + (.0001f) * pathSegment.ray.direction; +} + +__forceinline__ +__host__ __device__ +void Fresnel(PathSegment &pathSegment, glm::vec3 intersect, + glm::vec3 normal, const Material &m, thrust::default_random_engine &rng) { + float cosi = glm::clamp(-1.f, 1.f, glm::dot(pathSegment.ray.direction, normal)); + float etai = 1.f, etat = m.indexOfRefraction; + etai = cosi > 0 ? etat : etai; + etat = cosi > 0 ? etai : etat; + float sint = etai / etat * glm::sqrt(glm::max(0.f, 1.f - cosi * cosi)); + float kr = 0; + if (sint >= 1) { + // total internal reflection + SpecularBRDF(pathSegment, intersect, normal, m, rng); + } else { + float cost = glm::sqrt(glm::max(0.f, 1.f - sint * sint)); + cosi = glm::abs(cosi); + float Rs = ((etat * cosi) - (etai * cost)) / ((etat * cosi) + (etai * cost)); + float Rp = ((etai * cosi) - (etat * cost)) / ((etai * cosi) + (etat * cost)); + kr = (Rs * Rs + Rp * Rp) / 2; + } + thrust::uniform_real_distribution u01(0, 1); + if (u01(rng) < kr) { + SpecularBRDF(pathSegment, intersect, normal, m, rng); + } else { + SpecularBTDF(pathSegment, intersect, normal, m, rng); + } +} + /** * Scatter a ray with some probabilities according to the material properties. * For example, a diffuse surface scatters in a cosine-weighted hemisphere. @@ -72,8 +156,16 @@ void scatterRay( glm::vec3 intersect, 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. + thrust::default_random_engine &rng, + glm::vec3 texColor = glm::vec3(-1)) { + if (m.hasReflective && m.hasRefractive) { + // Fresnel + Fresnel(pathSegment, intersect, normal, m, rng); + } else if (m.hasReflective) { + SpecularBRDF(pathSegment, intersect, normal, m, rng); + } else if (m.hasRefractive) { + SpecularBTDF(pathSegment, intersect, normal, m, rng); + } else { + LambertBRDF(pathSegment, intersect, normal, m, rng); + } } diff --git a/src/intersections.h b/src/intersections.h index 6f23872..4cae3b1 100644 --- a/src/intersections.h +++ b/src/intersections.h @@ -35,6 +35,91 @@ __host__ __device__ glm::vec3 multiplyMV(glm::mat4 m, glm::vec4 v) { return glm::vec3(m * v); } +__forceinline__ +__host__ __device__ +void CoordinateSystem(const glm::vec3& v1, glm::vec3* v2, glm::vec3* v3) { + if (glm::abs(v1.x) > glm::abs(v1.y)) + *v2 = glm::vec3(-v1.z, 0, v1.x) / glm::sqrt(v1.x * v1.x + v1.z * v1.z); + else + *v2 = glm::vec3(0, v1.z, -v1.y) / glm::sqrt(v1.y * v1.y + v1.z * v1.z); + *v3 = glm::cross(v1, *v2); +} + +__host__ __device__ +glm::vec2 getCubeUV(const glm::vec3 &point) { + glm::vec3 abs = glm::min(glm::abs(point), 0.5f); + glm::vec2 UV;//Always offset lower-left corner + if(abs.x > abs.y && abs.x > abs.z) + { + UV = glm::vec2(point.z + 0.5f, point.y + 0.5f)/3.0f; + //Left face + if(point.x < 0) + { + UV += glm::vec2(0, 0.333f); + } + else + { + UV += glm::vec2(0, 0.667f); + } + } + else if(abs.y > abs.x && abs.y > abs.z) + { + UV = glm::vec2(point.x + 0.5f, point.z + 0.5f)/3.0f; + //Left face + if(point.y < 0) + { + UV += glm::vec2(0.333f, 0.333f); + } + else + { + UV += glm::vec2(0.333f, 0.667f); + } + } + else + { + UV = glm::vec2(point.x + 0.5f, point.y + 0.5f)/3.0f; + //Left face + if(point.z < 0) + { + UV += glm::vec2(0.667f, 0.333f); + } + else + { + UV += glm::vec2(0.667f, 0.667f); + } + } + return glm::clamp(UV, glm::vec2(0), glm::vec2(1)); +} + +__forceinline__ +__host__ __device__ +int sign(float i) { + return (i < 0) ? -1 : (i == 0.f) ? 0 : 1; +} + +__host__ __device__ +int GetFaceIndex(const glm::vec3 &P) { + int idx = 0; + float val = -1; + for (int i = 0; i < 3; i++) { + if (glm::abs(P[i]) > val) { + idx = i * sign(P[i]); + val = glm::abs(P[i]); + } + } + return idx; +} + +__host__ __device__ +void cubeComputeTBN(glm::mat4 transform, glm::mat4 invT, + const glm::vec3 P, glm::vec3 *nor, glm::vec3 *tan, glm::vec3 *bit) { + int idx = glm::abs(GetFaceIndex(glm::vec3(P))); + glm::vec3 N(0, 0, 0); + N[idx] = sign(P[idx]); + *nor = glm::vec3(glm::normalize(invT * glm::vec4(N, 0))); + CoordinateSystem(*nor, tan, bit); +} + // CHECKITOUT /** * Test intersection between a ray and a transformed cube. Untransformed, @@ -46,7 +131,7 @@ __host__ __device__ glm::vec3 multiplyMV(glm::mat4 m, glm::vec4 v) { * @return Ray parameter `t` value. -1 if no intersection. */ __host__ __device__ float boxIntersectionTest(Geom box, Ray r, - glm::vec3 &intersectionPoint, glm::vec3 &normal, bool &outside) { + glm::vec3 &intersectionPoint, glm::vec3 &normal, bool &outside, glm::vec2 &uv) { Ray q; q.origin = multiplyMV(box.inverseTransform, glm::vec4(r.origin , 1.0f)); q.direction = glm::normalize(multiplyMV(box.inverseTransform, glm::vec4(r.direction, 0.0f))); @@ -83,12 +168,33 @@ __host__ __device__ float boxIntersectionTest(Geom box, Ray r, outside = false; } intersectionPoint = multiplyMV(box.transform, glm::vec4(getPointOnRay(q, tmin), 1.0f)); + uv = getCubeUV(getPointOnRay(q, tmin)); normal = glm::normalize(multiplyMV(box.transform, glm::vec4(tmin_n, 0.0f))); return glm::length(r.origin - intersectionPoint); } return -1; } +__forceinline__ +__host__ __device__ +glm::vec2 getSphereUV(const glm::vec3 &point) { + glm::vec3 p = glm::normalize(point); + float phi = atan2f(p.z, p.x); + if (phi < 0) { + phi += TWO_PI; + } + float theta = glm::acos(p.y); + return glm::clamp(glm::vec2(1 - phi / TWO_PI, 1 - theta / PI), glm::vec2(0), glm::vec2(1)); +} + +__host__ __device__ +void sphereComputeTBN(glm::mat4 transform, glm::mat4 invT, + const glm::vec3 P, glm::vec3 *nor, glm::vec3 *tan, glm::vec3 *bit) { + *nor = glm::vec3(glm::normalize(invT * glm::vec4(glm::normalize(P), 0))); + *tan = glm::vec3(glm::normalize(transform * glm::vec4(glm::cross(glm::vec3(0, 1, 0), (glm::normalize(P))), 1))); + *bit = glm::normalize(glm::cross(*nor, *tan)); +} + // CHECKITOUT /** * Test intersection between a ray and a transformed sphere. Untransformed, @@ -100,7 +206,7 @@ __host__ __device__ float boxIntersectionTest(Geom box, Ray r, * @return Ray parameter `t` value. -1 if no intersection. */ __host__ __device__ float sphereIntersectionTest(Geom sphere, Ray r, - glm::vec3 &intersectionPoint, glm::vec3 &normal, bool &outside) { + glm::vec3 &intersectionPoint, glm::vec3 &normal, bool &outside, glm::vec2 &uv) { float radius = .5; glm::vec3 ro = multiplyMV(sphere.inverseTransform, glm::vec4(r.origin, 1.0f)); @@ -135,6 +241,7 @@ __host__ __device__ float sphereIntersectionTest(Geom sphere, Ray r, glm::vec3 objspaceIntersection = getPointOnRay(rt, t); intersectionPoint = multiplyMV(sphere.transform, glm::vec4(objspaceIntersection, 1.f)); + uv = getSphereUV(objspaceIntersection); normal = glm::normalize(multiplyMV(sphere.invTranspose, glm::vec4(objspaceIntersection, 0.f))); if (!outside) { normal = -normal; @@ -142,3 +249,217 @@ __host__ __device__ float sphereIntersectionTest(Geom sphere, Ray r, return glm::length(r.origin - intersectionPoint); } + +__host__ __device__ +float getArea(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3) { + glm::vec3 AB = p2 - p1; + glm::vec3 AC = p3 - p1; + return 0.5 * glm::length(glm::cross(AB, AC)); +} + +__host__ __device__ +glm::vec3 getTriangleNor(glm::vec3 P, glm::vec3 *vertices, glm::vec3 *nors) { + glm::vec3 v0 = vertices[1] - vertices[0]; + glm::vec3 v1 = vertices[2] - vertices[0]; + glm::vec3 v2 = P - vertices[0]; + float d00 = glm::dot(v0, v0); + float d01 = glm::dot(v0, v1); + float d11 = glm::dot(v1, v1); + float d20 = glm::dot(v2, v0); + float d21 = glm::dot(v2, v1); + float d = d00 * d11 - d01 * d01; + float l0 = (d11 * d20 - d01 * d21) / d; + float l1 = (d00 * d21 - d01 * d20) / d; + float l2 = 1 - l0 - l1; + + glm::vec3 result; + result.x = nors[0][0] * l2 + nors[1][0] * l0 + nors[2][0] * l1; + result.y = nors[0][1] * l2 + nors[1][1] * l0 + nors[2][1] * l1; + result.z = nors[0][2] * l2 + nors[1][2] * l0 + nors[2][2] * l1; + return result; +} + +__host__ __device__ +glm::vec2 getTriangleUV(glm::vec3 P, glm::vec3 *vertices, glm::vec2 *uvs) { + glm::vec3 v0 = vertices[1] - vertices[0]; + glm::vec3 v1 = vertices[2] - vertices[0]; + glm::vec3 v2 = P - vertices[0]; + float d00 = glm::dot(v0, v0); + float d01 = glm::dot(v0, v1); + float d11 = glm::dot(v1, v1); + float d20 = glm::dot(v2, v0); + float d21 = glm::dot(v2, v1); + float d = d00 * d11 - d01 * d01; + float l0 = (d11 * d20 - d01 * d21) / d; + float l1 = (d00 * d21 - d01 * d20) / d; + float l2 = 1 - l0 - l1; + + glm::vec2 result; + result.x = uvs[0][0] * l2 + uvs[1][0] * l0 + uvs[2][0] * l1; + result.y = uvs[0][1] * l2 + uvs[1][1] * l0 + uvs[2][1] * l1; + return result; +} + +__host__ __device__ +void triangleComputeTBN(Geom &geom, + glm::vec3 P, glm::vec3 *nor, glm::vec3 *tan, glm::vec3 *bit) { + *nor = getTriangleNor(P, geom.pos, geom.nor); + CoordinateSystem(*nor, tan, bit); +} + +__host__ __device__ +float triangleIntersectionTest(Geom tri, Ray r, glm::vec3 &intersectionPoint, + glm::vec3 &normal, bool &outside, glm::vec2 &uv) { + normal = -glm::normalize(glm::cross( + tri.pos[0] - tri.pos[1], + tri.pos[2] - tri.pos[1])); + + float D = glm::dot(normal, tri.pos[0]); + if (D == 0) { return -1; } + float t = (glm::dot(normal, tri.pos[0] - r.origin)) / glm::dot(normal, r.direction); + if (t < 0) { return -1; } + glm::vec3 P = r.origin + t * r.direction; + outside = true; + float S = getArea(tri.pos[0], tri.pos[1], tri.pos[2]); + float S1 = getArea(P, tri.pos[1], tri.pos[2]) / S; + float S2 = getArea(P, tri.pos[2], tri.pos[0]) / S; + float S3 = getArea(P, tri.pos[0], tri.pos[1]) / S; + + normal = getTriangleNor(P, tri.pos, tri.nor); + uv = getTriangleUV(P, tri.pos, tri.uv); + uv = glm::clamp(uv, glm::vec2(0), glm::vec2(1)); + + if (0 <= S1 && S1 <= 1 && + 0 <= S2 && S2 <= 1 && + 0 <= S3 && S3 <= 1 && (S1 + S2 + S3 - 1 < 0.001)) { + intersectionPoint = P; + return t; + } + return -1; +} + +__host__ __device__ +void computeTBN(Geom &geom, const glm::vec3 P, glm::vec3 *nor, glm::vec3 *tan, glm::vec3 *bit) { + if (geom.type == CUBE) { + cubeComputeTBN(geom.transform, geom.invTranspose, P, nor, tan, bit); + } else if (geom.type == SPHERE) { + sphereComputeTBN(geom.transform, geom.invTranspose, P, nor, tan, bit); + } else if (geom.type == TRIANGLE) { + triangleComputeTBN(geom, P, nor, tan, bit); + } +} + +// BOUNDING BOX STUFF +__host__ __device__ +float boundsIntersectionTest(Bounds b, Ray r) { + float tmin = -1e38f; + float tmax = 1e38f; + for (int xyz = 0; xyz < 3; ++xyz) { + float qdxyz = r.direction[xyz]; + /*if (glm::abs(qdxyz) > 0.00001f)*/ + { + float t1 = (b.min[xyz] - r.origin[xyz]) / qdxyz; + float t2 = (b.max[xyz] - r.origin[xyz]) / qdxyz; + float ta = glm::min(t1, t2); + float tb = glm::max(t1, t2); + if (ta > 0 && ta > tmin) + tmin = ta; + if (tb < tmax) + tmax = tb; + } + } + if (tmax >= tmin && tmax > 0) { + return tmin; + } + return -1; + +} + +__device__ __host__ +Bounds Union(const Bounds &b1, const Bounds &b2) { + Bounds ret; + ret.min.x = glm::min(b1.min.x, b2.min.x); + ret.min.y = glm::min(b1.min.y, b2.min.y); + ret.min.z = glm::min(b1.min.z, b2.min.z); + ret.max.x = glm::max(b1.max.x, b2.max.x); + ret.max.y = glm::max(b1.max.y, b2.max.y); + ret.max.z = glm::max(b1.max.z, b2.max.z); + return ret; +} + +Bounds GetBounds(Geom geo) { + if (geo.type == CUBE) { + std::vector world; + world.push_back(geo.transform * glm::vec4(-0.5, -0.5, -0.5, 1)); + world.push_back(geo.transform * glm::vec4(-0.5, -0.5, 0.5, 1)); + world.push_back(geo.transform * glm::vec4(-0.5, 0.5, -0.5, 1)); + world.push_back(geo.transform * glm::vec4(-0.5, 0.5, 0.5, 1)); + world.push_back(geo.transform * glm::vec4(0.5, -0.5, -0.5, 1)); + world.push_back(geo.transform * glm::vec4(0.5, -0.5, 0.5, 1)); + world.push_back(geo.transform * glm::vec4(0.5, 0.5, -0.5, 1)); + world.push_back(geo.transform * glm::vec4(0.5, 0.5, 0.5, 1)); + Bounds ret; + ret.min = glm::vec3(FLT_MAX); + ret.max = glm::vec3(FLT_MIN); + for (const auto &v : world) { + ret.min.x = v.x < ret.min.x ? v.x : ret.min.x; + ret.max.x = v.x > ret.max.x ? v.x : ret.max.x; + ret.min.y = v.y < ret.min.y ? v.y : ret.min.y; + ret.max.y = v.y > ret.max.y ? v.y : ret.max.y; + ret.min.z = v.z < ret.min.z ? v.z : ret.min.z; + ret.max.z = v.z > ret.max.z ? v.z : ret.max.z; + } + ret.max += glm::vec3(0.0001); + ret.min -= glm::vec3(0.0001); + return ret; + } else if (geo.type == SPHERE) { + glm::vec3 center = glm::vec3(0); + Bounds ret; + ret.min = glm::vec3(center - glm::vec3(0.5)); + ret.max = glm::vec3(center + glm::vec3(0.5)); + ret.min = multiplyMV(geo.transform, glm::vec4(ret.min, 1)); + ret.max = multiplyMV(geo.transform, glm::vec4(ret.max, 1)); + ret.max += glm::vec3(0.0001); + ret.min -= glm::vec3(0.0001); + return ret; + } else if (geo.type == TRIANGLE) { + Bounds b0 { geo.pos[0], geo.pos[0] }; + Bounds b1 { geo.pos[1], geo.pos[1] }; + Bounds b2 { geo.pos[2], geo.pos[2] }; + Bounds ret = Union(b0, Union(b1, b2)); + ret.max += glm::vec3(0.0001); + ret.min -= glm::vec3(0.0001); + return ret; + } + return { glm::vec3(0), glm::vec3(0) }; +} + +Bounds GetBounds(std::vector &geoms) { + if (geoms.size() == 0) { + return { glm::vec3(0), glm::vec3(0) }; + } + Bounds ret = GetBounds(geoms[0]); + for (const auto &geo : geoms) { + ret = Union(ret, GetBounds(geo)); + } + return ret; +} + +int longestAxis(Bounds &b) { + float xLength = b.max.x - b.min.x; + float yLength = b.max.y - b.min.y; + float zLength = b.max.z - b.min.z; + if (xLength > yLength && xLength > zLength) { + return 0; + } else if (yLength > xLength && yLength > zLength) { + return 1; + } else { + return 2; + } +} + +glm::vec3 getMidpoint(Bounds &b) { + return glm::vec3((b.max.x - b.min.x) / 2, + (b.max.y - b.min.y) / 2, + (b.max.z - b.min.z) / 2); +} \ No newline at end of file diff --git a/src/pathtrace.cu b/src/pathtrace.cu index c1ec122..614ac02 100644 --- a/src/pathtrace.cu +++ b/src/pathtrace.cu @@ -13,6 +13,7 @@ #include "pathtrace.h" #include "intersections.h" #include "interactions.h" +#include "defines.h" #define ERRORCHECK 1 @@ -73,6 +74,10 @@ static Geom * dev_geoms = NULL; static Material * dev_materials = NULL; static PathSegment * dev_paths = NULL; static ShadeableIntersection * dev_intersections = NULL; +static glm::vec3 *dev_tex = NULL; +#if KDTREE +static KDNode *dev_kdtree = NULL; +#endif // TODO: static variables for device memory, any extra info you need, etc // ... @@ -86,8 +91,13 @@ void pathtraceInit(Scene *scene) { cudaMalloc(&dev_paths, pixelcount * sizeof(PathSegment)); - cudaMalloc(&dev_geoms, scene->geoms.size() * sizeof(Geom)); - cudaMemcpy(dev_geoms, scene->geoms.data(), scene->geoms.size() * sizeof(Geom), cudaMemcpyHostToDevice); +#if KDTREE + cudaMalloc(&dev_geoms, scene->sortedGeoms.size() * sizeof(Geom)); + cudaMemcpy(dev_geoms, scene->sortedGeoms.data(), scene->sortedGeoms.size() * sizeof(Geom), cudaMemcpyHostToDevice); +#else + cudaMalloc(&dev_geoms, scene->geoms.size() * sizeof(Geom)); + cudaMemcpy(dev_geoms, scene->geoms.data(), scene->geoms.size() * sizeof(Geom), cudaMemcpyHostToDevice); +#endif cudaMalloc(&dev_materials, scene->materials.size() * sizeof(Material)); cudaMemcpy(dev_materials, scene->materials.data(), scene->materials.size() * sizeof(Material), cudaMemcpyHostToDevice); @@ -97,6 +107,14 @@ void pathtraceInit(Scene *scene) { // TODO: initialize any extra device memeory you need + // Allocate texture data + cudaMalloc(&dev_tex, scene->textureData.size() * sizeof(glm::vec3)); + cudaMemcpy(dev_tex, scene->textureData.data(), scene->textureData.size() * sizeof(glm::vec3), cudaMemcpyHostToDevice); + + #if KDTREE + cudaMalloc(&dev_kdtree, scene->kdtree.size() * sizeof(KDNode)); + cudaMemcpy(dev_kdtree, scene->kdtree.data(), scene->kdtree.size() * sizeof(KDNode), cudaMemcpyHostToDevice); + #endif checkCUDAError("pathtraceInit"); } @@ -108,6 +126,11 @@ void pathtraceFree() { cudaFree(dev_intersections); // TODO: clean up any extra device memory you created + cudaFree(dev_tex); + #if KDTREE + cudaFree(dev_kdtree); + #endif + checkCUDAError("pathtraceFree"); } @@ -129,18 +152,146 @@ __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.5, 0.5); - // 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; segment.remainingBounces = traceDepth; } } +__forceinline__ +__host__ __device__ +float getAlpha(float y, float py, float qy) { + return (y - py) / (qy - py); +} + +__forceinline__ +__host__ __device__ +glm::vec3 slerp(float alpha, glm::vec3 az, glm::vec3 bz) { + return glm::vec3((1 - alpha) * az.r + alpha * bz.r, + (1 - alpha) * az.g + alpha * bz.g, + (1 - alpha) * az.b + alpha * bz.b); +} + +__forceinline__ +__host__ __device__ +glm::vec3 fetchColor(glm::vec3 *textureData, const Material &m, int x, int y, bool texture = true) { + int pix = y * (texture ? m.texWidth : m.norWidth) + x; + return textureData[pix + (texture ? m.textureOffset : m.normalOffset)]; +} + +__global__ void computeIntersectionsKD(int depth, int num_paths, PathSegment *pathSegments, + Geom *geoms, KDNode *kdtree, int geoms_size, + ShadeableIntersection * intersections, + Material *mats, glm::vec3 *textureData) { + int path_index = blockIdx.x * blockDim.x + threadIdx.x; + + if (path_index < num_paths) { + PathSegment pathSegment = pathSegments[path_index]; + + float t; + float boundsT; + glm::vec3 intersect_point; + glm::vec3 normal; + glm::vec2 uv(0); + float t_min = FLT_MAX; + int hit_geom_index = -1; + bool outside = true; + + glm::vec3 tmp_intersect; + glm::vec3 tmp_normal; + glm::vec2 tmp_uv; + + // Traverse through kd tree + int toVisitOffset = 0, currentNodeIndex = 0; + int nodesToVisit[64]; + while (true) { + KDNode node = kdtree[currentNodeIndex]; + boundsT = boundsIntersectionTest(node.bounds, pathSegment.ray); + if (boundsT != -1.f) { + if (node.numPrims > 0) { + for (int i = 0; i < node.numPrims; ++i) { + Geom &geom = geoms[node.primOffset + i]; + if (geom.type == CUBE) { + t = boxIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, tmp_uv); + } else if (geom.type == SPHERE) { + t = sphereIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, tmp_uv); + } else if (geom.type == TRIANGLE) { + t = triangleIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, tmp_uv); + } + if (t > 0.0f && t_min > t) { + t_min = t; + hit_geom_index = node.primOffset + i; + intersect_point = tmp_intersect; + normal = tmp_normal; + uv = tmp_uv; + } + } + if (toVisitOffset == 0) { break; } + currentNodeIndex = nodesToVisit[--toVisitOffset]; + } else { + nodesToVisit[toVisitOffset++] = node.secondChildOffset; + currentNodeIndex = currentNodeIndex + 1; + } + } else { + if (toVisitOffset == 0) { break; } + currentNodeIndex = nodesToVisit[--toVisitOffset]; + } + } + + if (hit_geom_index == -1) { + intersections[path_index].t = -1.0f; + } else { + //The ray hits something + Material material = mats[geoms[hit_geom_index].materialid]; + if (material.normalOffset != -1) { + float w = material.norWidth - 1; + float h = material.norHeight - 1; + float u = uv[0]; + float v = uv[1]; + v = v < 0.5 ? v + 2 * (0.5 - v) : v - 2 * (v - 0.5); + float coordU = w * u; + float coordV = h * v; + if (coordV > material.norHeight || coordV < 0) { + printf("v out of bounds of texture %d x %d: %f with uv %f\n", material.norWidth, material.norHeight, coordV, v); + } + glm::vec3 first = slerp(getAlpha(coordU, glm::ceil(coordU), glm::floor(coordV)), + fetchColor(textureData, material, glm::ceil(coordU), glm::ceil(coordV), false), + fetchColor(textureData, material, glm::floor(coordU), glm::ceil(coordV), false)); + glm::vec3 second = slerp(getAlpha(coordU, glm::ceil(coordU), glm::floor(coordV)), + fetchColor(textureData, material, glm::ceil(coordU), glm::floor(coordV), false), + fetchColor(textureData, material, glm::floor(coordU), glm::floor(coordV), false)); + glm::vec3 texCol = slerp(getAlpha(coordV, glm::ceil(coordV), glm::floor(coordV)), first, second); + texCol = fetchColor(textureData, material, glm::floor(coordU), glm::floor(coordV), false); + glm::vec3 mapNor = texCol * glm::vec3(2.f) - glm::vec3(1.f); + // tangent space stuff + glm::vec3 nor; + glm::vec3 tan; + glm::vec3 bit; + Geom geom = geoms[hit_geom_index]; + computeTBN(geom, intersect_point, &nor, &tan, &bit); + + nor = glm::normalize(multiplyMV(geom.transform, glm::vec4(nor, 0.f))); + tan = glm::normalize(multiplyMV(geom.transform, glm::vec4(tan, 0.f))); + bit = glm::normalize(multiplyMV(geom.transform, glm::vec4(bit, 0.f))); + glm::mat3 TBN = glm::mat3(tan, bit, nor); + normal = TBN * mapNor; + } + + intersections[path_index].t = t_min; + intersections[path_index].materialId = geoms[hit_geom_index].materialid; + intersections[path_index].surfaceNormal = normal; + intersections[path_index].uv = uv; + } + } +} // TODO: // computeIntersections handles generating ray intersections ONLY. @@ -164,12 +315,14 @@ __global__ void computeIntersections( float t; glm::vec3 intersect_point; glm::vec3 normal; + glm::vec2 uv(0); float t_min = FLT_MAX; int hit_geom_index = -1; bool outside = true; glm::vec3 tmp_intersect; glm::vec3 tmp_normal; + glm::vec2 tmp_uv; // naive parse through global geoms @@ -177,13 +330,12 @@ __global__ void computeIntersections( { Geom & geom = geoms[i]; - if (geom.type == CUBE) - { - t = boxIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside); - } - else if (geom.type == SPHERE) - { - t = sphereIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside); + if (geom.type == CUBE) { + t = boxIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, tmp_uv); + } else if (geom.type == SPHERE) { + t = sphereIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, tmp_uv); + } else if (geom.type == TRIANGLE) { + t = triangleIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, tmp_uv); } // TODO: add more intersection tests here... triangle? metaball? CSG? @@ -195,6 +347,7 @@ __global__ void computeIntersections( hit_geom_index = i; intersect_point = tmp_intersect; normal = tmp_normal; + uv = tmp_uv; } } @@ -208,6 +361,7 @@ __global__ void computeIntersections( intersections[path_index].t = t_min; intersections[path_index].materialId = geoms[hit_geom_index].materialid; intersections[path_index].surfaceNormal = normal; + intersections[path_index].uv = uv; } } } @@ -265,6 +419,124 @@ __global__ void shadeFakeMaterial ( } } +// Warp functions +__forceinline__ +__host__ __device__ +glm::vec3 squareToDiskConcentric(const glm::vec2 &sample) { + glm::vec2 warp = sample * glm::vec2(2.f) - glm::vec2(1.f); + if (warp.x == 0 && warp.y == 0) { + return glm::vec3(0.f); + } + float theta, r; + if (std::abs(warp.x) > std::abs(warp.y)) { + r = warp.x; + theta = (PI / 4.f) * (warp.y / warp.x); + } else { + r = warp.y; + theta = (PI / 2.f) - (PI / 4.f) * (warp.x / warp.y); + } + return glm::vec3(r * std::cos(theta), r * std::sin(theta), 0); +} + +__forceinline__ +__host__ __device__ +glm::vec3 squareToHemisphereCosine(const glm::vec2 &sample) { + glm::vec3 diskSample = squareToDiskConcentric(sample); + float z = glm::sqrt(glm::max(0.f, 1.f - diskSample.x * diskSample.x - diskSample.y * diskSample.y)); + return glm::vec3(diskSample.x, diskSample.y, z); +} + +__forceinline__ +__host__ __device__ +float squareToHemisphereCosinePdf(const glm::vec3 &sample) { + float d = glm::sqrt(sample.x * sample.x + sample.y * sample.y); + return INV_PI * glm::cos(glm::asin(d)); +} + +__forceinline__ +__host__ __device__ +float AbsDot(const glm::vec3 &v1, const glm::vec3 &v2) { + return glm::abs(glm::dot(v1, v2)); +} + +// BSDF Functions +// Pass in wo and a material, isect, and sample +// fills in wi, pdf, f + +__host__ __device__ +void bxdfLambertDiffuse(const glm::vec3 &wo, Material &mat, ShadeableIntersection &isect, thrust::default_random_engine &rng, + glm::vec3 *wi, glm::vec3 *f, float *pdf) { + *wi = calculateRandomDirectionInHemisphere(isect.surfaceNormal, rng); + //if (wo.z < 0) { wi->z *= -1; } + *pdf = AbsDot(isect.surfaceNormal, *wi) * INV_PI; + *f = mat.color; +} + +__host__ __device__ +void bxdfPerfectSpecular(const glm::vec3 &wo, Material &mat, ShadeableIntersection &isect, thrust::default_random_engine &rng, + glm::vec3 *wi, glm::vec3 *f, float *pdf) { + *wi = glm::reflect(-wo, isect.surfaceNormal); + *pdf = 1.f; + *f = mat.color; +} + +__global__ +void shadeMaterial(int iter, int numPaths, + ShadeableIntersection *shadeableIntersections, + PathSegment *pathSegments, + Material *materials, glm::vec3 *textureData, int depth) +{ + int idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx >= numPaths || pathSegments[idx].remainingBounces <= 0) { return; } + 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, depth); + thrust::uniform_real_distribution u01(0, 1); + + Material material = materials[intersection.materialId]; + glm::vec3 materialColor = material.color; + + if (material.textureOffset != -1) { + // texture exists for this material + float w = material.texWidth - 1; + float h = material.texHeight - 1; + float u = intersection.uv[0]; + float v = intersection.uv[1]; + v = v < 0.5 ? v + 2 * (0.5 - v) : v - 2 * (v - 0.5); + float coordU = w * u; + float coordV = h * v; + if (coordV > material.texHeight || coordV < 0) { + printf("v out of bounds of texture %d x %d: %f with uv %f\n", material.texWidth, material.texHeight, coordV, v); + } + glm::vec3 first = slerp(getAlpha(coordU, glm::ceil(coordU), glm::floor(coordV)), + fetchColor(textureData, material, glm::ceil(coordU), glm::ceil(coordV)), + fetchColor(textureData, material, glm::floor(coordU), glm::ceil(coordV))); + glm::vec3 second = slerp(getAlpha(coordU, glm::ceil(coordU), glm::floor(coordV)), + fetchColor(textureData, material, glm::ceil(coordU), glm::floor(coordV)), + fetchColor(textureData, material, glm::floor(coordU), glm::floor(coordV))); + glm::vec3 texCol = slerp(getAlpha(coordV, glm::ceil(coordV), glm::floor(coordV)), first, second); + texCol = fetchColor(textureData, material, glm::floor(coordU), glm::floor(coordV)); + pathSegments[idx].color *= texCol; + } + + // If the material indicates that the object was a light, "light" the ray + if (material.emittance > 0.0f) { + pathSegments[idx].color *= (materialColor * material.emittance); + pathSegments[idx].remainingBounces = 0; + } else { + // Evaluate the BRDF (done in scatterRay) + scatterRay(pathSegments[idx], getPointOnRay(pathSegments[idx].ray, intersection.t), intersection.surfaceNormal, material, rng); + pathSegments[idx].remainingBounces--; + } + } else { + pathSegments[idx].color = glm::vec3(0.0f); + pathSegments[idx].remainingBounces = 0; + } +} + // Add the current iteration's output to the overall image __global__ void finalGather(int nPaths, glm::vec3 * image, PathSegment * iterationPaths) { @@ -277,6 +549,12 @@ __global__ void finalGather(int nPaths, glm::vec3 * image, PathSegment * iterati } } +struct endPath { + __host__ __device__ bool operator()(const PathSegment &pathSegment) { + return pathSegment.remainingBounces > 0; + } +}; + /** * Wrapper for the __global__ call that sets up the kernel calls and does a ton * of memory management @@ -344,6 +622,13 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { // tracing dim3 numblocksPathSegmentTracing = (num_paths + blockSize1d - 1) / blockSize1d; + + #if KDTREE + computeIntersectionsKD << > > ( + depth, num_paths, dev_paths, dev_geoms, dev_kdtree, hst_scene->geoms.size(), + dev_intersections, dev_materials, dev_tex + ); + #else computeIntersections <<>> ( depth , num_paths @@ -352,6 +637,7 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { , hst_scene->geoms.size() , dev_intersections ); + #endif checkCUDAError("trace one bounce"); cudaDeviceSynchronize(); depth++; @@ -360,20 +646,38 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { // 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. + // 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 + //); + shadeMaterial << > > ( + iter, + num_paths, + dev_intersections, + dev_paths, + dev_materials, dev_tex, depth + ); + checkCUDAError("shading"); + + cudaDeviceSynchronize(); + +#if STREAM_COMPACT + dev_path_end = thrust::partition(thrust::device, dev_paths, dev_path_end, endPath()); + auto numPaths = (dev_path_end - dev_paths); + + iterationComplete = numPaths == 0 || depth == traceDepth; +#else + iterationComplete = depth == traceDepth; // TODO: should be based off stream compaction results. +#endif } // Assemble this iteration and apply it to the image diff --git a/src/scene.cpp b/src/scene.cpp index cbae043..047ba59 100644 --- a/src/scene.cpp +++ b/src/scene.cpp @@ -3,6 +3,10 @@ #include #include #include +#include "tiny_obj_loader.h" +#include +#include +#include "defines.h" Scene::Scene(string filename) { cout << "Reading scene from " << filename << " ..." << endl; @@ -30,20 +34,39 @@ Scene::Scene(string filename) { } } } + + #if KDTREE + KDHelperNode *root = buildKDTreeCPU(geoms, 0, 200); + int numNodes = countNodes(root); + for (int i = 0; i < numNodes; ++i) { + kdtree.push_back(KDNode()); + } + int offset = 0; + flattenKDTree(root, sortedGeoms, kdtree, &offset); + #endif + + cout << endl << "Scene statistics: " << endl; + cout << geoms.size() << " primitives" << endl; + #if KDTREE + cout << numNodes << " kd nodes" << endl; + #endif } int Scene::loadGeom(string objectid) { int id = atoi(objectid.c_str()); - if (id != geoms.size()) { + /*if (id != geoms.size()) { cout << "ERROR: OBJECT ID does not match expected number of geoms" << endl; return -1; - } else { + } else */{ cout << "Loading Geom " << id << "..." << endl; + bool isMesh = false; + string meshFile; Geom newGeom; string line; //load object type utilityCore::safeGetline(fp_in, line); + vector tokens = utilityCore::tokenizeString(line); if (!line.empty() && fp_in.good()) { if (strcmp(line.c_str(), "sphere") == 0) { cout << "Creating new sphere..." << endl; @@ -51,15 +74,22 @@ int Scene::loadGeom(string objectid) { } else if (strcmp(line.c_str(), "cube") == 0) { cout << "Creating new cube..." << endl; newGeom.type = CUBE; - } + } else if (strcmp(tokens[0].c_str(), "mesh") == 0) { + cout << "Creating new mesh..." << endl; + // tokens[1] is filename of obj + // read obj, and add all triangles to geoms + meshFile = tokens[1]; + isMesh = true; + } } //link material utilityCore::safeGetline(fp_in, line); if (!line.empty() && fp_in.good()) { - vector tokens = utilityCore::tokenizeString(line); - newGeom.materialid = atoi(tokens[1].c_str()); - cout << "Connecting Geom " << objectid << " to Material " << newGeom.materialid << "..." << endl; + vector tokens = utilityCore::tokenizeString(line); + newGeom.materialid = atoi(tokens[1].c_str()); + cout << "Connecting Geom " << objectid << " to Material " << newGeom.materialid << "..." << endl; + } //load transformations @@ -79,16 +109,103 @@ 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); + if (!isMesh) { + newGeom.transform = utilityCore::buildTransformationMatrix( + newGeom.translation, newGeom.rotation, newGeom.scale); + newGeom.inverseTransform = glm::inverse(newGeom.transform); + newGeom.invTranspose = glm::inverseTranspose(newGeom.transform); + + geoms.push_back(newGeom); + } else { + // read meshFile and get triangles + // create new Geometry for each triangle + // set transform, inverse transform, and transpose for each triangle + // add triangle to geoms + std::vector mtls; + std::vector tris; + loadMesh(meshFile, tris); + for (auto &tri : tris) { + tri.translation = newGeom.translation; + tri.rotation = newGeom.rotation; + tri.scale = newGeom.scale; + tri.transform = utilityCore::buildTransformationMatrix( + tri.translation, tri.rotation, tri.scale); + tri.inverseTransform = glm::inverse(tri.transform); + tri.invTranspose = glm::inverseTranspose(tri.transform); + tri.pos[0] = glm::vec3(tri.transform * glm::vec4(tri.pos[0], 1)); + tri.pos[1] = glm::vec3(tri.transform * glm::vec4(tri.pos[1], 1)); + tri.pos[2] = glm::vec3(tri.transform * glm::vec4(tri.pos[2], 1)); + tri.materialid = newGeom.materialid; + geoms.push_back(tri); + } + } - geoms.push_back(newGeom); return 1; } } +int Scene::loadMesh(string filename, std::vector &tris) { + tinyobj::attrib_t attrib; + std::vector shapes; + std::vector materials; + std::string err; + std::string basedir = ""; + if (filename.find_last_of("/\\") != std::string::npos) { + basedir = filename.substr(0, filename.find_last_of("/\\")); + } + + bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename.c_str(), basedir.c_str()); + if (!err.empty()) { + std::cerr << err << std::endl; + } + if (!ret) { + std::cerr << "Skipping " << filename << std::endl; + return -1; + } + + 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++) { + int fv = 3; // all objs should have only triangles + + Geom tri; + tri.type = TRIANGLE; + + // Loop over vertices in the face. + for (size_t v = 0; v < fv; v++) { + // access to vertex + tinyobj::index_t idx = shapes[s].mesh.indices[index_offset + v]; + tinyobj::real_t vx = attrib.vertices[3 * idx.vertex_index + 0]; + tinyobj::real_t vy = attrib.vertices[3 * idx.vertex_index + 1]; + tinyobj::real_t vz = attrib.vertices[3 * idx.vertex_index + 2]; + tinyobj::real_t nx = 0; + tinyobj::real_t ny = 0; + tinyobj::real_t nz = 0; + if (attrib.normals.size() > 0) { + nx = attrib.normals[3 * idx.normal_index + 0]; + ny = attrib.normals[3 * idx.normal_index + 1]; + nz = attrib.normals[3 * idx.normal_index + 2]; + } + tinyobj::real_t tx = 0; + tinyobj::real_t ty = 0; + if (attrib.texcoords.size() > 0) { + tx = attrib.texcoords[2 * idx.texcoord_index + 0]; + ty = attrib.texcoords[2 * idx.texcoord_index + 1]; + } + + tri.pos[v] = glm::vec3(vx, vy, vz); + tri.nor[v] = glm::vec3(nx, ny, nz); + tri.uv[v] = glm::vec2(tx, ty); + } + index_offset += fv; + + // per-face material + tris.push_back(tri); + } + } +} + int Scene::loadCamera() { cout << "Loading Camera ..." << endl; RenderState &state = this->state; @@ -158,9 +275,10 @@ int Scene::loadMaterial(string materialid) { } else { cout << "Loading Material " << id << "..." << endl; Material newMaterial; - + newMaterial.textureOffset = -1; + newMaterial.normalOffset = -1; //load static properties - for (int i = 0; i < 7; i++) { + for (int i = 0; i < 10; i++) { string line; utilityCore::safeGetline(fp_in, line); vector tokens = utilityCore::tokenizeString(line); @@ -180,9 +298,181 @@ int Scene::loadMaterial(string materialid) { newMaterial.indexOfRefraction = atof(tokens[1].c_str()); } else if (strcmp(tokens[0].c_str(), "EMITTANCE") == 0) { newMaterial.emittance = atof(tokens[1].c_str()); - } + } else if (strcmp(tokens[0].c_str(), "DISP") == 0) { + newMaterial.dispersion = atof(tokens[1].c_str()); + } else if (strcmp(tokens[0].c_str(), "TEX") == 0 && tokens.size() == 2 && strcmp(tokens[1].c_str(), "NONE") != 0) { + // tokens[1] is the filename of the texture + int channels = 0; + float *rawTexData = stbi_loadf(tokens[1].c_str(), &newMaterial.texWidth, &newMaterial.texHeight, &channels, 3); + newMaterial.textureOffset = textureData.size(); + if (channels == 3 || channels == 4) { + for (int i = 0; i < newMaterial.texWidth * newMaterial.texHeight; ++i) { + glm::vec3 color; + color.r = rawTexData[i * channels]; + color.g = rawTexData[i * channels + 1]; + color.b = rawTexData[i * channels + 2]; + textureData.push_back(color); + } + std::cout << "Successfully loaded texture " << tokens[1] << std::endl; + } else { + std::cerr << "Error loading texture " << tokens[1] << std::endl; + } + stbi_image_free(rawTexData); + } else if (strcmp(tokens[0].c_str(), "NOR") == 0 && tokens.size() == 2 && strcmp(tokens[1].c_str(), "NONE") != 0) { + int channels = 0; + float *rawTexData = stbi_loadf(tokens[1].c_str(), &newMaterial.norWidth, &newMaterial.norHeight, &channels, 3); + newMaterial.normalOffset = textureData.size(); + if (channels == 3 || channels == 4) { + for (int i = 0; i < newMaterial.norWidth * newMaterial.norHeight; ++i) { + glm::vec3 color; + color.r = rawTexData[i * channels]; + color.g = rawTexData[i * channels + 1]; + color.b = rawTexData[i * channels + 2]; + textureData.push_back(color); + } + std::cout << "Successfully loaded normal map " << tokens[1] << std::endl; + } else { + std::cerr << "Error loading normal map " << tokens[1] << std::endl; + } + stbi_image_free(rawTexData); + } } materials.push_back(newMaterial); return 1; } } + +KDHelperNode *Scene::buildKDTreeCPU(std::vector &geoms, int depth, int maxDepth) { + KDHelperNode *node = new KDHelperNode(); + node->left = nullptr; + node->right = nullptr; + node->bounds = GetBounds(geoms); + + if (geoms.size() <= 4 || depth > maxDepth) { + node->geoms = geoms; + return node; + } + + int axis = longestAxis(node->bounds); + if (glm::abs(node->bounds.max[axis] - node->bounds.min[axis]) < 0.001) { + node->geoms = geoms; + return node; + } + std::vector rightGeos; + std::vector leftGeos; + +#if SPLIT_SAH + // Cost in cost() and split() + float splitPoint = split(geoms, axis, node->bounds.min[axis], node->bounds.max[axis]); + for (const auto &g : geoms) { + Bounds b = GetBounds(g); + float p = b.min[axis] + ((b.max[axis] - b.min[axis]) / 2.f); + if (p > splitPoint) { + rightGeos.push_back(g); + float min = b.min[axis]; + } else { + leftGeos.push_back(g); + float max = b.max[axis]; + } + } +#else + std::sort(geoms.begin(), geoms.end(), [&](const Geom &g1, const Geom &g2) { + return getMidpoint(GetBounds(g1))[axis] < getMidpoint(GetBounds(g2))[axis]; + }); + leftGeos = std::vector(geoms.begin(), geoms.begin() + (geoms.size() / 2)); + rightGeos = std::vector(geoms.begin() + (geoms.size() / 2), geoms.end()); +#endif + node->left = buildKDTreeCPU(leftGeos, depth + 1, maxDepth); + node->right = buildKDTreeCPU(rightGeos, depth + 1, maxDepth); + node->axis = axis; + return node; +} + +int Scene::countNodes(KDHelperNode *node) { + if (node->left == nullptr && node->right == nullptr) { + return 1; + } + int size = 0; + if (node->left != nullptr) { + size += countNodes(node->left); + } + if (node->right != nullptr) { + size += countNodes(node->right); + } + return size + 1; +} + +int Scene::flattenKDTree(KDHelperNode *helperNode, std::vector &sortedGeoms, std::vector &kdtree, int *offset) { + KDNode *node = &kdtree[*offset]; + node->bounds = helperNode->bounds; + int myOffset = (*offset)++; + if (helperNode->left == nullptr || helperNode->right == nullptr) { + //leaf + node->primOffset = sortedGeoms.size(); + for (Geom g : helperNode->geoms) { + sortedGeoms.push_back(g); + } + node->numPrims = helperNode->geoms.size(); + } else { + // interior node + node->axis = helperNode->axis; + node->numPrims = 0; + flattenKDTree(helperNode->left, sortedGeoms, kdtree, offset); + node->secondChildOffset = flattenKDTree(helperNode->right, sortedGeoms, kdtree, offset); + } + return myOffset; +} + +float Scene::cost(float split, const std::vector &geoms, int axis, float min, float max) { + int leftGeos = 0; + int rightGeos = 0; + + // determine where each geometry is relative to the split + for (int i = 0; i < geoms.size(); ++i) { + Geom g = geoms[i]; + Bounds b = GetBounds(g); + // world space geometry midpoint + float p = b.min[axis] + ((b.max[axis] - b.min[axis]) / 2.f); + if (p > split) { + rightGeos++; + float min = b.min[axis]; + if (min <= split) { + leftGeos++; + } + } else { + leftGeos++; + float max = b.max[axis]; + if (max >= split) { + rightGeos++; + } + } + } + float leftSize = split - min; + float rightSize = max - split; + return (leftSize * leftGeos) + (rightSize * rightGeos); +} + +float Scene::split(const std::vector &geoms, int axis, float min, float max) { + float center = (min + max) / 2.f; + float geoMedian = 0; + for (const auto &g : geoms) { + Bounds b = GetBounds(g); + geoMedian += b.min[axis] + ((b.max[axis] - b.min[axis]) / 2.f); + } + + geoMedian /= geoms.size(); + + float step = (center - geoMedian) / N_BUCKETS; + float minCost = FLT_MAX; + float bestSplit = geoMedian; + if (glm::abs(step) > EPSILON) { + for (float i = geoMedian; i < center; i += step) { + float c = cost(i, geoms, axis, min, max); + if (minCost > c) { + minCost = c; + bestSplit = i; + } + } + } + return bestSplit; +} \ No newline at end of file diff --git a/src/scene.h b/src/scene.h index f29a917..4162bd2 100644 --- a/src/scene.h +++ b/src/scene.h @@ -15,12 +15,29 @@ class Scene { ifstream fp_in; int loadMaterial(string materialid); int loadGeom(string objectid); + int loadMesh(string filename, std::vector &tris); int loadCamera(); + + KDHelperNode *buildKDTreeCPU(std::vector &geoms, int depth, int maxDepth); + int flattenKDTree(KDHelperNode *root, std::vector &sortedGeoms, std::vector &kdtree, int *offset); + int countNodes(KDHelperNode *node); + float cost(float split, const std::vector &geoms, int axis, float min, float max); + float split(const std::vector &geoms, int axis, float min, float max); public: Scene(string filename); ~Scene(); std::vector geoms; + std::vector sortedGeoms; // for flattened kd tree + std::vector kdtree; std::vector materials; + std::vector textureData; RenderState state; }; + +__host__ __device__ +Bounds Union(const Bounds &b1, const Bounds &b2); +Bounds GetBounds(Geom geo); +Bounds GetBounds(std::vector &geoms); +int longestAxis(Bounds &b); +glm::vec3 getMidpoint(Bounds &b); \ No newline at end of file diff --git a/src/sceneStructs.h b/src/sceneStructs.h index b38b820..782675d 100644 --- a/src/sceneStructs.h +++ b/src/sceneStructs.h @@ -10,6 +10,7 @@ enum GeomType { SPHERE, CUBE, + TRIANGLE }; struct Ray { @@ -26,6 +27,11 @@ struct Geom { glm::mat4 transform; glm::mat4 inverseTransform; glm::mat4 invTranspose; + + // Triangle information + glm::vec3 pos[3]; + glm::vec3 nor[3]; + glm::vec2 uv[3]; }; struct Material { @@ -37,7 +43,14 @@ struct Material { float hasReflective; float hasRefractive; float indexOfRefraction; + float dispersion; float emittance; + int textureOffset; + int texWidth; + int texHeight; + int normalOffset; + int norWidth; + int norHeight; }; struct Camera { @@ -73,4 +86,29 @@ struct ShadeableIntersection { float t; glm::vec3 surfaceNormal; int materialId; + glm::vec2 uv; +}; + +struct Bounds { + glm::vec3 min; + glm::vec3 max; +}; + +struct KDHelperNode { + Bounds bounds; + KDHelperNode *left; + KDHelperNode *right; + uint8_t axis; + std::vector geoms; +}; + +struct KDNode { + Bounds bounds; // 24 bytes + union { // 4 bytes + uint32_t primOffset; // if leaf + uint32_t secondChildOffset; // if interior + }; + uint16_t numPrims; // non zero if leaf + uint8_t axis; // 1 byte + uint8_t pad[1]; }; diff --git a/src/tiny_obj_loader.cc b/src/tiny_obj_loader.cc new file mode 100644 index 0000000..e57d044 --- /dev/null +++ b/src/tiny_obj_loader.cc @@ -0,0 +1,2 @@ +#define TINYOBJLOADER_IMPLEMENTATION +#include "tiny_obj_loader.h" diff --git a/src/tiny_obj_loader.h b/src/tiny_obj_loader.h new file mode 100644 index 0000000..f627e94 --- /dev/null +++ b/src/tiny_obj_loader.h @@ -0,0 +1,2518 @@ +/* +The MIT License (MIT) + +Copyright (c) 2012-2018 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.2.3 : Added color space extension('-colorspace') to tex opts. +// version 1.2.2 : Parse multiple group names. +// version 1.2.1 : Added initial support for line('l') primitive(PR #178) +// version 1.2.0 : Hardened implementation(#175) +// version 1.1.1 : Support smoothing groups(#162) +// 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. +// + +// +// Use this in *one* .cc +// #define TINYOBJLOADER_IMPLEMENTATION +// #include "tiny_obj_loader.h" +// + +#ifndef TINY_OBJ_LOADER_H_ +#define TINY_OBJ_LOADER_H_ + +#include +#include +#include + +namespace tinyobj { + +#ifdef __clang__ +#pragma clang diagnostic push +#if __has_warning("-Wzero-as-null-pointer-constant") +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif + +#pragma clang diagnostic ignored "-Wpadded" + +#endif + +// 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 +// +// TinyObjLoader extension. +// +// -colorspace SPACE # Color space of the texture. e.g. 'sRGB` or 'linear' +// + +#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) + + // extension + std::string colorspace; // Explicitly specify color space of stored value. Usually `sRGB` or `linear` (default empty). +} 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 smoothing_group_ids; // per-face smoothing group + // ID(0 = off. positive value + // = group id) + std::vector tags; // SubD tag +} mesh_t; + +typedef struct { + std::vector indices; // pairs of indices for lines +} path_t; + +typedef struct { + std::string name; + mesh_t mesh; + path_t path; +} 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. +/// Option 'default_vcols_fallback' specifies whether vertex colors should +/// always be defined, even if no colors are given (fallback to white). +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, bool default_vcols_fallback = 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, bool default_vcols_fallback = 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 +#include + +namespace tinyobj { + +MaterialReader::~MaterialReader() {} + +struct vertex_index_t { + int v_idx, vt_idx, vn_idx; + vertex_index_t() : v_idx(-1), vt_idx(-1), vn_idx(-1) {} + explicit vertex_index_t(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {} + vertex_index_t(int vidx, int vtidx, int vnidx) + : v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {} +}; + +// Internal data structure for face representation +// index + smoothing group. +struct face_t { + unsigned int + smoothing_group_id; // smoothing group id. 0 = smoothing groupd is off. + int pad_; + std::vector vertex_indices; // face vertex indices. + + face_t() : smoothing_group_id(0) {} +}; + +struct line_t { + int idx0; + int idx1; +}; + +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); + + const bool found_color = parseReal(token, r) && parseReal(token, g) && parseReal(token, b); + + if (!found_color) { + (*r) = (*g) = (*b) = 1.0; + } + + return found_color; +} + +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_t *ret) { + if (!ret) { + return false; + } + + vertex_index_t 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_t parseRawTriple(const char **token) { + vertex_index_t 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 = static_cast(1.0); + texopt->clamp = false; + texopt->blendu = true; + texopt->blendv = true; + texopt->sharpness = static_cast(1.0); + texopt->brightness = static_cast(0.0); + texopt->contrast = static_cast(1.0); + texopt->origin_offset[0] = static_cast(0.0); + texopt->origin_offset[1] = static_cast(0.0); + texopt->origin_offset[2] = static_cast(0.0); + texopt->scale[0] = static_cast(1.0); + texopt->scale[1] = static_cast(1.0); + texopt->scale[2] = static_cast(1.0); + texopt->turbulence[0] = static_cast(0.0); + texopt->turbulence[1] = static_cast(0.0); + texopt->turbulence[2] = static_cast(0.0); + 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 if ((0 == strncmp(token, "-colorspace", 11)) && IS_SPACE((token[11]))) { + token += 12; + texopt->colorspace = parseString(&token); + } 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] = static_cast(0.0); + material->diffuse[i] = static_cast(0.0); + material->specular[i] = static_cast(0.0); + material->transmittance[i] = static_cast(0.0); + material->emission[i] = static_cast(0.0); + } + material->illum = 0; + material->dissolve = static_cast(1.0); + material->shininess = static_cast(1.0); + material->ior = static_cast(1.0); + + material->roughness = static_cast(0.0); + material->metallic = static_cast(0.0); + material->sheen = static_cast(0.0); + material->clearcoat_thickness = static_cast(0.0); + material->clearcoat_roughness = static_cast(0.0); + material->anisotropy_rotation = static_cast(0.0); + material->anisotropy = static_cast(0.0); + material->roughness_texname = ""; + material->metallic_texname = ""; + material->sheen_texname = ""; + material->emissive_texname = ""; + material->normal_texname = ""; + + material->unknown_parameter.clear(); +} + +// code from https://wrf.ecse.rpi.edu//Research/Short_Notes/pnpoly.html +template +static int pnpoly(int nvert, T *vertx, T *verty, T testx, T testy) { + int i, j, c = 0; + for (i = 0, j = nvert - 1; i < nvert; j = i++) { + if (((verty[i] > testy) != (verty[j] > testy)) && + (testx < + (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) + + vertx[i])) + c = !c; + } + return c; +} + +// TODO(syoyo): refactor function. +static bool exportGroupsToShape(shape_t *shape, + const std::vector &faceGroup, + std::vector &lineGroup, + const std::vector &tags, + const int material_id, const std::string &name, + bool triangulate, + const std::vector &v) { + if (faceGroup.empty() && lineGroup.empty()) { + return false; + } + + if (!faceGroup.empty()) { + // Flatten vertices and indices + for (size_t i = 0; i < faceGroup.size(); i++) { + const face_t &face = faceGroup[i]; + + size_t npolys = face.vertex_indices.size(); + + if (npolys < 3) { + // Face must have 3+ vertices. + continue; + } + + vertex_index_t i0 = face.vertex_indices[0]; + vertex_index_t i1(-1); + vertex_index_t i2 = face.vertex_indices[1]; + + if (triangulate) { + // find the two axes to work in + size_t axes[2] = {1, 2}; + for (size_t k = 0; k < npolys; ++k) { + i0 = face.vertex_indices[(k + 0) % npolys]; + i1 = face.vertex_indices[(k + 1) % npolys]; + i2 = face.vertex_indices[(k + 2) % npolys]; + size_t vi0 = size_t(i0.v_idx); + size_t vi1 = size_t(i1.v_idx); + size_t vi2 = size_t(i2.v_idx); + + if (((3 * vi0 + 2) >= v.size()) || ((3 * vi1 + 2) >= v.size()) || + ((3 * vi2 + 2) >= v.size())) { + // Invalid triangle. + // FIXME(syoyo): Is it ok to simply skip this invalid triangle? + continue; + } + real_t v0x = v[vi0 * 3 + 0]; + real_t v0y = v[vi0 * 3 + 1]; + real_t v0z = v[vi0 * 3 + 2]; + real_t v1x = v[vi1 * 3 + 0]; + real_t v1y = v[vi1 * 3 + 1]; + real_t v1z = v[vi1 * 3 + 2]; + real_t v2x = v[vi2 * 3 + 0]; + real_t v2y = v[vi2 * 3 + 1]; + real_t v2z = v[vi2 * 3 + 2]; + real_t e0x = v1x - v0x; + real_t e0y = v1y - v0y; + real_t e0z = v1z - v0z; + real_t e1x = v2x - v1x; + real_t e1y = v2y - v1y; + real_t e1z = v2z - v1z; + real_t cx = std::fabs(e0y * e1z - e0z * e1y); + real_t cy = std::fabs(e0z * e1x - e0x * e1z); + real_t cz = std::fabs(e0x * e1y - e0y * e1x); + const real_t epsilon = std::numeric_limits::epsilon(); + if (cx > epsilon || cy > epsilon || cz > epsilon) { + // found a corner + if (cx > cy && cx > cz) { + } else { + axes[0] = 0; + if (cz > cx && cz > cy) axes[1] = 1; + } + break; + } + } + + real_t area = 0; + for (size_t k = 0; k < npolys; ++k) { + i0 = face.vertex_indices[(k + 0) % npolys]; + i1 = face.vertex_indices[(k + 1) % npolys]; + size_t vi0 = size_t(i0.v_idx); + size_t vi1 = size_t(i1.v_idx); + if (((vi0 * 3 + axes[0]) >= v.size()) || + ((vi0 * 3 + axes[1]) >= v.size()) || + ((vi1 * 3 + axes[0]) >= v.size()) || + ((vi1 * 3 + axes[1]) >= v.size())) { + // Invalid index. + continue; + } + real_t v0x = v[vi0 * 3 + axes[0]]; + real_t v0y = v[vi0 * 3 + axes[1]]; + real_t v1x = v[vi1 * 3 + axes[0]]; + real_t v1y = v[vi1 * 3 + axes[1]]; + area += (v0x * v1y - v0y * v1x) * static_cast(0.5); + } + + int maxRounds = 10; // arbitrary max loop count to protect against + // unexpected errors + + face_t remainingFace = face; // copy + size_t guess_vert = 0; + vertex_index_t ind[3]; + real_t vx[3]; + real_t vy[3]; + while (remainingFace.vertex_indices.size() > 3 && maxRounds > 0) { + npolys = remainingFace.vertex_indices.size(); + if (guess_vert >= npolys) { + maxRounds -= 1; + guess_vert -= npolys; + } + for (size_t k = 0; k < 3; k++) { + ind[k] = remainingFace.vertex_indices[(guess_vert + k) % npolys]; + size_t vi = size_t(ind[k].v_idx); + if (((vi * 3 + axes[0]) >= v.size()) || + ((vi * 3 + axes[1]) >= v.size())) { + // ??? + vx[k] = static_cast(0.0); + vy[k] = static_cast(0.0); + } else { + vx[k] = v[vi * 3 + axes[0]]; + vy[k] = v[vi * 3 + axes[1]]; + } + } + real_t e0x = vx[1] - vx[0]; + real_t e0y = vy[1] - vy[0]; + real_t e1x = vx[2] - vx[1]; + real_t e1y = vy[2] - vy[1]; + real_t cross = e0x * e1y - e0y * e1x; + // if an internal angle + if (cross * area < static_cast(0.0)) { + guess_vert += 1; + continue; + } + + // check all other verts in case they are inside this triangle + bool overlap = false; + for (size_t otherVert = 3; otherVert < npolys; ++otherVert) { + size_t idx = (guess_vert + otherVert) % npolys; + + if (idx >= remainingFace.vertex_indices.size()) { + // ??? + continue; + } + + size_t ovi = size_t(remainingFace.vertex_indices[idx].v_idx); + + if (((ovi * 3 + axes[0]) >= v.size()) || + ((ovi * 3 + axes[1]) >= v.size())) { + // ??? + continue; + } + real_t tx = v[ovi * 3 + axes[0]]; + real_t ty = v[ovi * 3 + axes[1]]; + if (pnpoly(3, vx, vy, tx, ty)) { + overlap = true; + break; + } + } + + if (overlap) { + guess_vert += 1; + continue; + } + + // this triangle is an ear + { + index_t idx0, idx1, idx2; + idx0.vertex_index = ind[0].v_idx; + idx0.normal_index = ind[0].vn_idx; + idx0.texcoord_index = ind[0].vt_idx; + idx1.vertex_index = ind[1].v_idx; + idx1.normal_index = ind[1].vn_idx; + idx1.texcoord_index = ind[1].vt_idx; + idx2.vertex_index = ind[2].v_idx; + idx2.normal_index = ind[2].vn_idx; + idx2.texcoord_index = ind[2].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); + shape->mesh.smoothing_group_ids.push_back(face.smoothing_group_id); + } + + // remove v1 from the list + size_t removed_vert_index = (guess_vert + 1) % npolys; + while (removed_vert_index + 1 < npolys) { + remainingFace.vertex_indices[removed_vert_index] = + remainingFace.vertex_indices[removed_vert_index + 1]; + removed_vert_index += 1; + } + remainingFace.vertex_indices.pop_back(); + } + + if (remainingFace.vertex_indices.size() == 3) { + i0 = remainingFace.vertex_indices[0]; + i1 = remainingFace.vertex_indices[1]; + i2 = remainingFace.vertex_indices[2]; + { + 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); + shape->mesh.smoothing_group_ids.push_back(face.smoothing_group_id); + } + } + } else { + for (size_t k = 0; k < npolys; k++) { + index_t idx; + idx.vertex_index = face.vertex_indices[k].v_idx; + idx.normal_index = face.vertex_indices[k].vn_idx; + idx.texcoord_index = face.vertex_indices[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->mesh.smoothing_group_ids.push_back( + face.smoothing_group_id); // per face + } + } + + shape->name = name; + shape->mesh.tags = tags; + } + + if (!lineGroup.empty()) { + shape->path.indices.swap(lineGroup); + } + + 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 = static_cast(1.0) - 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, bool default_vcols_fallback) { + 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 = mtl_basedir ? mtl_basedir : ""; + if (!baseDir.empty()) { +#ifndef _WIN32 + const char dirsep = '/'; +#else + const char dirsep = '\\'; +#endif + if (baseDir[baseDir.length() - 1] != dirsep) baseDir += dirsep; + } + MaterialFileReader matFileReader(baseDir); + + return LoadObj(attrib, shapes, materials, err, &ifs, &matFileReader, + trianglulate, default_vcols_fallback); +} + +bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *err, + std::istream *inStream, MaterialReader *readMatFn /*= NULL*/, + bool triangulate, bool default_vcols_fallback) { + std::stringstream errss; + + std::vector v; + std::vector vn; + std::vector vt; + std::vector vc; + std::vector tags; + std::vector faceGroup; + std::vector lineGroup; + std::string name; + + // material + std::map material_map; + int material = -1; + + // smoothing group id + unsigned int current_smoothing_id = + 0; // Initial value. 0 means no smoothing. + + int greatest_v_idx = -1; + int greatest_vn_idx = -1; + int greatest_vt_idx = -1; + + shape_t shape; + + bool found_all_colors = true; + + size_t line_num = 0; + std::string linebuf; + while (inStream->peek() != -1) { + safeGetline(*inStream, linebuf); + + line_num++; + + // 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; + + found_all_colors &= parseVertexWithColor(&x, &y, &z, &r, &g, &b, &token); + + v.push_back(x); + v.push_back(y); + v.push_back(z); + + if (found_all_colors || default_vcols_fallback) { + 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; + } + + // line + if (token[0] == 'l' && IS_SPACE((token[1]))) { + token += 2; + + line_t line_cache; + bool end_line_bit = 0; + while (!IS_NEW_LINE(token[0])) { + // get index from string + int idx; + fixIndex(parseInt(&token), 0, &idx); + + size_t n = strspn(token, " \t\r"); + token += n; + + if (!end_line_bit) { + line_cache.idx0 = idx; + } else { + line_cache.idx1 = idx; + lineGroup.push_back(line_cache.idx0); + lineGroup.push_back(line_cache.idx1); + line_cache = line_t(); + } + end_line_bit = !end_line_bit; + } + + continue; + } + // face + if (token[0] == 'f' && IS_SPACE((token[1]))) { + token += 2; + token += strspn(token, " \t"); + + face_t face; + + face.smoothing_group_id = current_smoothing_id; + face.vertex_indices.reserve(3); + + while (!IS_NEW_LINE(token[0])) { + vertex_index_t 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; + } + + greatest_v_idx = greatest_v_idx > vi.v_idx ? greatest_v_idx : vi.v_idx; + greatest_vn_idx = greatest_vn_idx > vi.vn_idx ? greatest_vn_idx : vi.vn_idx; + greatest_vt_idx = greatest_vt_idx > vi.vt_idx ? greatest_vt_idx : vi.vt_idx; + + face.vertex_indices.push_back(vi); + size_t n = strspn(token, " \t\r"); + token += n; + } + + // replace with emplace_back + std::move on C++11 + faceGroup.push_back(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 `exportGroupsToShape()` call. + exportGroupsToShape(&shape, faceGroup, lineGroup, tags, material, name, + triangulate, v); + 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 = exportGroupsToShape(&shape, faceGroup, lineGroup, tags, + material, name, triangulate, v); + (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; + + while (!IS_NEW_LINE(token[0])) { + std::string str = parseString(&token); + names.push_back(str); + token += strspn(token, " \t\r"); // skip tag + } + + // names[0] must be 'g' + + if (names.size() < 2) { + // 'g' with empty names + if (err) { + std::stringstream ss; + ss << "WARN: Empty group name. line: " << line_num << "\n"; + (*err) += ss.str(); + name = ""; + } + } else { + + std::stringstream ss; + ss << names[1]; + + // tinyobjloader does not support multiple groups for a primitive. + // Currently we concatinate multiple group names with a space to get + // single group name. + + for (size_t i = 2; i < names.size(); i++) { + ss << " " << names[i]; + } + + name = ss.str(); + + } + + continue; + } + + // object name + if (token[0] == 'o' && IS_SPACE((token[1]))) { + // flush previous face group. + bool ret = exportGroupsToShape(&shape, faceGroup, lineGroup, tags, + material, name, triangulate, v); + 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])) { + const int max_tag_nums = 8192; // FIXME(syoyo): Parameterize. + tag_t tag; + + token += 2; + + tag.name = parseString(&token); + + tag_sizes ts = parseTagTriple(&token); + + if (ts.num_ints < 0) { + ts.num_ints = 0; + } + if (ts.num_ints > max_tag_nums) { + ts.num_ints = max_tag_nums; + } + + if (ts.num_reals < 0) { + ts.num_reals = 0; + } + if (ts.num_reals > max_tag_nums) { + ts.num_reals = max_tag_nums; + } + + if (ts.num_strings < 0) { + ts.num_strings = 0; + } + if (ts.num_strings > max_tag_nums) { + ts.num_strings = max_tag_nums; + } + + 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); + + continue; + } + + if (token[0] == 's' && IS_SPACE(token[1])) { + // smoothing group id + token += 2; + + // skip space. + token += strspn(token, " \t"); // skip space + + if (token[0] == '\0') { + continue; + } + + if (token[0] == '\r' || token[1] == '\n') { + continue; + } + + if (strlen(token) >= 3) { + if (token[0] == 'o' && token[1] == 'f' && token[2] == 'f') { + current_smoothing_id = 0; + } + } else { + // assume number + int smGroupId = parseInt(&token); + if (smGroupId < 0) { + // parse error. force set to 0. + // FIXME(syoyo): Report warning. + current_smoothing_id = 0; + } else { + current_smoothing_id = static_cast(smGroupId); + } + } + + continue; + } // smoothing group id + + // Ignore unknown command. + } + + // not all vertices have colors, no default colors desired? -> clear colors + if (!found_all_colors && !default_vcols_fallback) { + vc.clear(); + } + + if (greatest_v_idx >= static_cast(v.size() / 3)) + { + if (err) { + std::stringstream ss; + ss << "WARN: Vertex indices out of bounds.\n" << std::endl; + (*err) += ss.str(); + } + } + if (greatest_vn_idx >= static_cast(vn.size() / 3)) + { + if (err) { + std::stringstream ss; + ss << "WARN: Vertex normal indices out of bounds.\n" << std::endl; + (*err) += ss.str(); + } + } + if (greatest_vt_idx >= static_cast(vt.size() / 2)) + { + if (err) { + std::stringstream ss; + ss << "WARN: Vertex texcoord indices out of bounds.\n" << std::endl; + (*err) += ss.str(); + } + } + + bool ret = exportGroupsToShape(&shape, faceGroup, lineGroup, tags, material, + name, triangulate, v); + // exportGroupsToShape 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::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_t 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); + + 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; +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +} // namespace tinyobj + +#endif diff --git a/src/utilities.h b/src/utilities.h index abb4f27..896edf1 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -10,6 +10,8 @@ #include #define PI 3.1415926535897932384626422832795028841971f +#define INV_PI 0.3183098861837906715377675267450287240689f +#define PI_OVER_4 0.7853981633974483096156608458198757210492f #define TWO_PI 6.2831853071795864769252867665590057683943f #define SQRT_OF_ONE_THIRD 0.5773502691896257645091487805019574556476f #define EPSILON 0.00001f