diff --git a/README.md b/README.md index 110697c..302cb1b 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,126 @@ CUDA Path Tracer ================ -**University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 3** +### Sample render -* (TODO) YOUR NAME HERE -* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab) +a scene including different materials : **pure reflective**, **diffuse**, and **refraction with reflect** based on Schlick's approximation -### (TODO: Your README) +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/cornell.2018-09-30_16-46-42z.4007samp.png) -*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. +### Glass Dragon +```resolution``` : 1000X1000 ```iteration``` : 2000 ```render time``` : 25min ```vertex count``` : 12.5k + +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/dragonKD2000iter.png ) + +### Interactions + +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/ddfddddddd.gif ) + +# Features: +- **Basic features** + - A shading kernel with BSDF evaluation for: + - Ideal diffuse shader. + - perfect specular reflective surface. + - Stream compaction for terminating unwanted thread from thread pool using thrust::partition + - material sorting using thrust::sort_by_key + - caching first bounce information for future iteration use +- **Advanced features** + - refreaction with Frensel effects using Schlick's approximation + - physically based depth of field + + - in short, this effect is achieved by jittering the ray within a certain area. + - to be more clear, for each ray, we will first create a point having a specific distance (i.e the focal length) away from the cam . + - then, according to the conventional knowledge we learned from high school, when we are looking through the lens, we can think it as we are actually looking from another position dpending on the rfraction ratio of the lens, simmilarily, we will change the origin of the ray in the code by using a concentric disk sampling method as well as the focal radius as a parameter to determine how obvious we want the effect to be, then, since we have the origin and target, we can have our new DOF ray. + + ![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/doffix.JPG) + + - stochastic sampled antialiasing + - achieved by jittering the ray before it's generated from the camera. + - this method is actually a little bit like the mutiple-sampling anti-aliasing (MSAA) method in rasterization, the basic idea for both are like this: pick neccessary information for generating color buffers from different target instead of just one. + - now we take a look at the following image, to the left of the image, what we see is the not anti-aliased version result of rendering a simple trangle, the right image , however, is what happend when we choose to jitter the rays, we will get color info from different locations, therefore giving us nicer renders. + + ![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/anti_aliasing_sample_points.png) + + - the following image explicitly shows the benefit of AA by doing a comparision of same scene with and with out it. + +AA off | AA on +------|------ +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/aaoff.JPG)|![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/aaon.JPG) + - arbitrary mesh loading and rendering + - used [tinyObj loader](http://syoyo.github.io/tinyobjloader/) + - used glm's triangle intersection method + - bounding bolumn intersection toggle +### Dragon + +```resolution``` : 1000X1000 ```iteration``` : 2000 ```render time``` : 25min for glass, 28min for specular ```vertex count``` : 12.5k + +Glass dragon | Specular dragon +------|------ +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/dragonKD2000iter.png )|![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/dragonspecular2000iter.png ) + +### Sword + +a great sword of Artorias the Abysswalker from dark souls series with simple specular material +```resolution``` : 1000X1000 ```iteration``` : 5000 ```render time``` : 26min ```vertex count``` : 1k + +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/sword2.png) + + - KD tree for mesh rendering acceleration + - Spectrum rendering: + + ![](img/cornell.2018-11-16_18-01-14z.810samp.png) + +# Performance analysis: + +## stream compaction +- stream compaction is needed because if we don't do this, a lot of the threads will simply contribute no efforts once their current work is done, this can result from situations like ray's remaining bounces turned to zero in code (varous reasons can cause this, like hitting the light source, or the ray simply run out of 'depth'), hence, we can simply terminate these unneeded thread stalling, and put them into use again using stream compaction. +- one thing I discover is that stram compaction would not be that good in a closed scene, which I think can be reasulting from the rays keep travling inside the box without being able to get out of it increases the reamaining bounces higher number possibility for each ray, what happens is that ray can only get terminated in two ways: meet the light source or reach the maximum bounce number. + +## cache first bounce: + +- We want to cache the first iteration's information because before the first bounce, all the information including ray origin ray directions are all the same in spite of different iterations. +- according to the chart bellow, by caching the first bounce, we slightly improved the efficiency + +time cost to 500 iterations: + +time(ms) |cached | no cache +--------------|---------|------- +test scene| 31861.30 | 34134.12 + +## sort material: +- For different rays, depending on the material of object they hit, the rays will perform differently, and it's always better to put rays that hit the same material closely in the same block instead of those having different materials, this will prevent some unneccesary stalling condition caused by rays' different behaviour(different thread running time). +- In terms of my own test, with sorting toggled on, the program always experience slower performace than before, I guess this is because the number of materials is not big enough to cover the efficiency lost from the sorting operation. + +## bounding box for mesh +- it's quite obvious that by adding bounding box to mesh we can prevent unneccessary triangle checks from happenning, resulting in some performance improvement. +- here's my test result (naive)time cost to 100 iterations + +time(sec) |added | not added +--------------|---------|------- +dragon| 597.20 | 623.11 + +## KD tree acceleration : + +time cost to 100 iterations + +time(secs) |dragon(12.5 kverts) |sword (1k verts) +--------------|---------|------- +KD accelerated| 121| 32 +Nive| 603| 50 + +![](https://github.com/LanLou123/Project3-CUDA-Path-Tracer/raw/master/img/kdeffect.JPG ) + + - I choosed to implement a KD tree for the acceleration of obj loading, the following are the main features of the tree + - For the spatial division, I made the current tree node to divide along the longest axis of the node's bounding box, since it minimize the waste of extra divisions, + - Another thing about division is the magnitude of it, I choosed to use the metric that when the left child node and right child node is having more than half of their triangles in common, we stop doing the division. + - After we build the tree on cpu, we can trasfer the tree's data to GPU + - In GPU, since recursion and stl library is unavailable, I instead passed two extra buffers to GPU : first one ```dev_KDtreenode``` which is the array of kdtree nodes each having idx of it's children ,it's parents' index ,bouding box and triangle idx in gpu triangle list, second one : ```dev_gputriidxlst``` which is an array especially for storing triangle indices mapping from kdtree to the actual triangle buffer for each node. + - as for the target node(containing intersected triangle) searching algorithm, I used a mutation of an iterative in-order binary tree search method and C - style stack, I don't think this is a good solution, but it works and give me no small performance boost, but anyway, I will change to use a better method in the future. + +# References +- [KD Trees for Faster Ray Tracing ](https://blog.frogslayer.com/kd-trees-for-faster-ray-tracing-with-triangles/) +- [ConcentricSampleDisk function](https://pub.dartlang.org/documentation/dartray/0.0.1/core/ConcentricSampleDisk.html) +- [GPU gem3](https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_pref01.html) +- [Schlick's approximation wiki](https://en.wikipedia.org/wiki/Schlick's_approximation) +- some iterative solutions for binary search tree diff --git a/antialiasingexample1.png b/antialiasingexample1.png new file mode 100644 index 0000000..ce06aa0 Binary files /dev/null and b/antialiasingexample1.png differ diff --git a/diamond.png b/diamond.png new file mode 100644 index 0000000..5df101a Binary files /dev/null and b/diamond.png differ diff --git a/dragonKD2000iter.png b/dragonKD2000iter.png new file mode 100644 index 0000000..42142c8 Binary files /dev/null and b/dragonKD2000iter.png differ diff --git a/dragonlowpoly.png b/dragonlowpoly.png new file mode 100644 index 0000000..3a3c352 Binary files /dev/null and b/dragonlowpoly.png differ diff --git a/dragonspeculartest.png b/dragonspeculartest.png new file mode 100644 index 0000000..5227a12 Binary files /dev/null and b/dragonspeculartest.png differ diff --git a/greatswordofArtorias.png b/greatswordofArtorias.png new file mode 100644 index 0000000..aa8a26c Binary files /dev/null and b/greatswordofArtorias.png differ diff --git a/img/aaoff.JPG b/img/aaoff.JPG new file mode 100644 index 0000000..22e97dc Binary files /dev/null and b/img/aaoff.JPG differ diff --git a/img/aaoff.png b/img/aaoff.png new file mode 100644 index 0000000..ffcf172 Binary files /dev/null and b/img/aaoff.png differ diff --git a/img/aaon.JPG b/img/aaon.JPG new file mode 100644 index 0000000..b7aec94 Binary files /dev/null and b/img/aaon.JPG differ diff --git a/img/aaon.png b/img/aaon.png new file mode 100644 index 0000000..24fd463 Binary files /dev/null and b/img/aaon.png differ diff --git a/img/anothersordimg.png b/img/anothersordimg.png new file mode 100644 index 0000000..efba5b4 Binary files /dev/null and b/img/anothersordimg.png differ diff --git a/img/anti_aliasing_sample_points.png b/img/anti_aliasing_sample_points.png new file mode 100644 index 0000000..7fb9a07 Binary files /dev/null and b/img/anti_aliasing_sample_points.png differ diff --git a/img/cornell.2018-09-30_16-46-42z.4007samp.png b/img/cornell.2018-09-30_16-46-42z.4007samp.png new file mode 100644 index 0000000..14444df Binary files /dev/null and b/img/cornell.2018-09-30_16-46-42z.4007samp.png differ diff --git a/img/cornell.2018-11-16_16-38-12z.497samp.png b/img/cornell.2018-11-16_16-38-12z.497samp.png new file mode 100644 index 0000000..85553df Binary files /dev/null and b/img/cornell.2018-11-16_16-38-12z.497samp.png differ diff --git a/img/cornell.2018-11-16_16-55-54z.1054samp.png b/img/cornell.2018-11-16_16-55-54z.1054samp.png new file mode 100644 index 0000000..397af7b Binary files /dev/null and b/img/cornell.2018-11-16_16-55-54z.1054samp.png differ diff --git a/img/cornell.2018-11-16_18-01-14z.1074samp.png b/img/cornell.2018-11-16_18-01-14z.1074samp.png new file mode 100644 index 0000000..a0d40bf Binary files /dev/null and b/img/cornell.2018-11-16_18-01-14z.1074samp.png differ diff --git a/img/cornell.2018-11-16_18-01-14z.810samp.png b/img/cornell.2018-11-16_18-01-14z.810samp.png new file mode 100644 index 0000000..17e61d3 Binary files /dev/null and b/img/cornell.2018-11-16_18-01-14z.810samp.png differ diff --git a/img/ddfddddddd.gif b/img/ddfddddddd.gif new file mode 100644 index 0000000..854f7f7 Binary files /dev/null and b/img/ddfddddddd.gif differ diff --git a/img/doffix.JPG b/img/doffix.JPG new file mode 100644 index 0000000..cf29a2a Binary files /dev/null and b/img/doffix.JPG differ diff --git a/img/dragonspecular2000iter.png b/img/dragonspecular2000iter.png new file mode 100644 index 0000000..548215d Binary files /dev/null and b/img/dragonspecular2000iter.png differ diff --git a/img/kdeffect.JPG b/img/kdeffect.JPG new file mode 100644 index 0000000..9c443bf Binary files /dev/null and b/img/kdeffect.JPG differ diff --git a/img/sword2.png b/img/sword2.png new file mode 100644 index 0000000..3524d31 Binary files /dev/null and b/img/sword2.png differ diff --git a/img/sword2000iter.png b/img/sword2000iter.png new file mode 100644 index 0000000..2921352 Binary files /dev/null and b/img/sword2000iter.png differ diff --git a/infinitemirror.png b/infinitemirror.png new file mode 100644 index 0000000..12e217c Binary files /dev/null and b/infinitemirror.png differ diff --git a/liquid dragon.png b/liquid dragon.png new file mode 100644 index 0000000..db4049b Binary files /dev/null and b/liquid dragon.png differ diff --git a/scenes/cornell.txt b/scenes/cornell.txt index 83ff820..e913061 100644 --- a/scenes/cornell.txt +++ b/scenes/cornell.txt @@ -6,7 +6,8 @@ SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 -EMITTANCE 5 +EMITTANCE 2.5 +DIFFUSE 0 // Diffuse white MATERIAL 1 @@ -17,16 +18,18 @@ REFL 0 REFR 0 REFRIOR 0 EMITTANCE 0 +DIFFUSE 1 -// Diffuse red +// Diffuse blue MATERIAL 2 -RGB .85 .35 .35 +RGB .95 .35 .39 SPECEX 0 SPECRGB 0 0 0 REFL 0 REFR 0 REFRIOR 0 EMITTANCE 0 +DIFFUSE 1 // Diffuse green MATERIAL 3 @@ -37,20 +40,76 @@ REFL 0 REFR 0 REFRIOR 0 EMITTANCE 0 +DIFFUSE 1 // Specular white MATERIAL 4 RGB .98 .98 .98 SPECEX 0 -SPECRGB .98 .98 .98 +SPECRGB .98 .38 .38 REFL 1 REFR 0 REFRIOR 0 EMITTANCE 0 +DIFFUSE 0 + +// Refractive white +MATERIAL 5 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB 1 1 1 +REFL 0 +REFR 1 +REFRIOR 2 +EMITTANCE 0 +DIFFUSE 0 + +// Reflective green +MATERIAL 6 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .35 .95 .35 +REFL 1 +REFR 0 +REFRIOR 0 +EMITTANCE 0 +DIFFUSE 0 + +// Reflective white +MATERIAL 7 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .95 .95 .95 +REFL 1 +REFR 0 +REFRIOR 0 +EMITTANCE 0 +DIFFUSE 0 + +MATERIAL 8 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .25 .85 .95 +REFL 1 +REFR 0 +REFRIOR 0 +EMITTANCE 0 +DIFFUSE 0 + + +MATERIAL 9 +RGB .98 .98 .98 +SPECEX 0 +SPECRGB .25 .85 .95 +REFL 1 +REFR 0 +REFRIOR 0 +EMITTANCE 0 +DIFFUSE 1 // Camera CAMERA -RES 800 800 +RES 1000 1000 FOVY 45 ITERATIONS 5000 DEPTH 8 @@ -64,7 +123,7 @@ UP 0 1 0 OBJECT 0 cube material 0 -TRANS 0 10 0 +TRANS 2 10 1 ROTAT 0 0 0 SCALE 3 .3 3 @@ -74,7 +133,7 @@ cube material 1 TRANS 0 0 0 ROTAT 0 0 0 -SCALE 10 .01 10 +SCALE 10 .01 30 // Ceiling OBJECT 2 @@ -82,36 +141,61 @@ cube material 1 TRANS 0 10 0 ROTAT 0 0 90 -SCALE .01 10 10 +SCALE .01 20 20 // Back wall OBJECT 3 cube material 1 -TRANS 0 5 -5 +TRANS 0 5 -10 ROTAT 0 90 0 SCALE .01 10 10 // Left wall OBJECT 4 cube -material 2 +material 4 TRANS -5 5 0 ROTAT 0 0 0 -SCALE .01 10 10 +SCALE .01 10 20 // Right wall OBJECT 5 cube -material 3 +material 6 TRANS 5 5 0 ROTAT 0 0 0 -SCALE .01 10 10 +SCALE .01 10 20 -// Sphere +// Ceiling light OBJECT 6 -sphere -material 4 -TRANS -1 4 -1 +cube +material 0 +TRANS -2 10 1 ROTAT 0 0 0 -SCALE 3 3 3 +SCALE 3 .3 3 + +// Ceiling light +OBJECT 7 +cube +material 0 +TRANS -2 10 -5 +ROTAT 0 0 0 +SCALE 3 .3 3 + +// Ceiling light +OBJECT 8 +cube +material 0 +TRANS 2 10 -5 +ROTAT 0 0 0 +SCALE 3 .3 3 + +OBJECT 9 +mesh +../scenes/diamond.obj +material 5 +TRANS 0 0 0 +ROTAT 0 0 0 +SCALE 2 2 2 + diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index a1cb3fb..5f86136 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -6,6 +6,7 @@ set(SOURCE_FILES "intersections.h" "glslUtility.hpp" "glslUtility.cpp" + "tiny_obj_loader.h" "pathtrace.cu" "pathtrace.h" "scene.cpp" @@ -15,9 +16,11 @@ set(SOURCE_FILES "preview.cpp" "utilities.cpp" "utilities.h" + "KDtreeNode.h" + "KDtreeNode.cpp" ) cuda_add_library(src ${SOURCE_FILES} - OPTIONS -arch=sm_20 + OPTIONS -arch=sm_60 ) diff --git a/src/KDtreeNode.cpp b/src/KDtreeNode.cpp new file mode 100644 index 0000000..0f3f96b --- /dev/null +++ b/src/KDtreeNode.cpp @@ -0,0 +1,100 @@ +#include"KDtreeNode.h" + + + +int KDtreeNode::computeLongestAxis(glm::vec3 maxv, glm::vec3 minv) +{ + int axis; + glm::vec3 diff = maxv - minv; + if (diff.x >= diff.y && diff.x >= diff.z) axis = 0; + else if (diff.y >= diff.x&& diff.y >= diff.z) axis = 1; + else if (diff.z >= diff.x && diff.z >= diff.y) axis = 2; + return axis; +} + +void KDtreeNode::Build(KDtreeNode* node,vector tris, int depth, int& nodecount,KDtreeNode* parent) +{ + nodecount++; + node->triangles = tris; + node->right = NULL; + node->left = NULL; + node->depth = depth; + node->nodeidx = nodecount; + node->parent = parent; + + if (tris.size() == 0) + { + node = NULL; + return; + } + + + if (tris.size() == 1) + { + node->BoundingBox.maxB = tris[0].BoundingBox.maxB; + node->BoundingBox.minB = tris[0].BoundingBox.minB; + node->right = NULL; + node->left = NULL; + return; + } + + glm::vec3 mid(0); + glm::vec3 maxbb(-(1e+8)); + glm::vec3 minbb(1e+8); + + for (int i = 0; i < tris.size(); ++i) + { + maxbb.x = maxbb.x < tris[i].BoundingBox.maxB.x ? tris[i].BoundingBox.maxB.x : maxbb.x; + maxbb.y = maxbb.y < tris[i].BoundingBox.maxB.y ? tris[i].BoundingBox.maxB.y : maxbb.y; + maxbb.z = maxbb.z < tris[i].BoundingBox.maxB.z ? tris[i].BoundingBox.maxB.z : maxbb.z; + + minbb.x = minbb.x > tris[i].BoundingBox.minB.x ? tris[i].BoundingBox.minB.x : minbb.x; + minbb.y = minbb.y > tris[i].BoundingBox.minB.y ? tris[i].BoundingBox.minB.y : minbb.y; + minbb.z = minbb.z > tris[i].BoundingBox.minB.z ? tris[i].BoundingBox.minB.z : minbb.z; + + mid += tris[i].computeMidpt()*(1.0f / tris.size()); + } + node->BoundingBox.maxB = maxbb; + node->BoundingBox.minB = minbb; + vector left_tris; + vector right_tris; + int axis = node->computeLongestAxis(node->BoundingBox.maxB, node->BoundingBox.minB); + for (int i = 0; i < tris.size(); ++i) + { + switch (axis) + { + case 0: + mid.x >= tris[i].computeMidpt().x ? right_tris.push_back(tris[i]) : left_tris.push_back(tris[i]); + break; + case 1: + mid.y >= tris[i].computeMidpt().y ? right_tris.push_back(tris[i]) : left_tris.push_back(tris[i]); + break; + case 2: + mid.z >= tris[i].computeMidpt().z ? right_tris.push_back(tris[i]) : left_tris.push_back(tris[i]); + break; + } + } + if (left_tris.size() == 0 && right_tris.size() > 0) left_tris = right_tris; + if (right_tris.size() == 0 && left_tris.size() > 0) right_tris = left_tris; + + int match = 0; + for (int i = 0; i < left_tris.size(); ++i) + { + for (int j = 0; j < right_tris.size(); ++j) + { + if (left_tris[i] == right_tris[j]) match++; + } + } + if ((float)match / left_tris.size() < 0.5 && (float)match / right_tris.size() < 0.5) + { + node->right = new KDtreeNode(); + node->left = new KDtreeNode(); + Build(node->left ,left_tris, depth + 1,nodecount,node); + Build(node->right ,right_tris, depth + 1,nodecount,node); + } + else + { + node->right = NULL; + node->left = NULL; + } +} \ No newline at end of file diff --git a/src/KDtreeNode.h b/src/KDtreeNode.h new file mode 100644 index 0000000..3985b7d --- /dev/null +++ b/src/KDtreeNode.h @@ -0,0 +1,37 @@ +#ifndef KDTREE_NODE_H +#define KDTREE_NODE_H + +#include +#include + +#include "../src/sceneStructs.h" + +#include +#include +using namespace std; + +class KDtreeNode { +public: + struct + { + glm::vec3 maxB; + glm::vec3 minB; + }BoundingBox; + int depth; + KDtreeNode* left; + KDtreeNode* right; + KDtreeNode* parent; + int nodeidx; + vector triangles; + KDtreeNode() {BoundingBox.maxB = glm::vec3(0); BoundingBox.minB = glm::vec3(0); }; + KDtreeNode(glm::vec3& Meshmaxbound, glm::vec3 Meshminbound) { BoundingBox.maxB = Meshmaxbound; + BoundingBox.minB = Meshminbound; + }; + void Build(KDtreeNode* node, vector tris, int depth, int& nodecount, KDtreeNode* parent); + int computeLongestAxis(glm::vec3 maxv,glm::vec3 minv); +}; + + + + +#endif // !OCT_TREE_H diff --git a/src/interactions.h b/src/interactions.h index 5ce3628..9be8dce 100644 --- a/src/interactions.h +++ b/src/interactions.h @@ -73,7 +73,143 @@ void scatterRay( glm::vec3 normal, const Material &m, thrust::default_random_engine &rng) { - // TODO: implement this. - // A basic implementation of pure-diffuse shading will just call the - // calculateRandomDirectionInHemisphere defined above. + thrust::uniform_real_distribution u01(0,1); + float rand = u01(rng); + if (m.emittance > 0) + { + pathSegment.color *= m.color*m.emittance; + pathSegment.remainingBounces = 0; + return; + } + else if (m.hasReflective>0&&m.diffuse>0) + { + float diffmag = 0.8; + if (rand<=diffmag) + { + pathSegment.ray.direction = calculateRandomDirectionInHemisphere(normal, rng); + pathSegment.color *= m.specular.color; + } + else + { + pathSegment.ray.direction = glm::normalize(glm::reflect(pathSegment.ray.direction, normal)); + pathSegment.color *= m.specular.color; + } + pathSegment.ray.origin = intersect + 0.001f*normal; + pathSegment.remainingBounces--; + } + else if (m.hasReflective > 0) + { + float lambertVal = fabs(glm::dot(normal, (pathSegment.ray.direction))); + pathSegment.remainingBounces--; + pathSegment.ray.origin = intersect+0.001f*normal; + pathSegment.ray.direction = glm::normalize(glm::reflect(pathSegment.ray.direction, normal)); + pathSegment.color *= m.specular.color; + //pathSegment.color *= lambertVal*m.color; + } + //Schlick's approximation + else if (rand > 1 - m.hasRefractive && rand < 1) + { + float epsilon = 1e-7; + float actualidx; + float rf_c = 0.2f; + glm::vec3 actualcol = m.color; + actualidx = m.indexOfRefraction; + actualidx += rf_c*(1-(pathSegment.ray.wavelength)); + float rlerp = abs(pathSegment.ray.wavelength - 0.86f); + float glerp = abs(pathSegment.ray.wavelength - 0.5f); + float blerp = abs(pathSegment.ray.wavelength - 0.18f); + + //rlerp = 1.f - rlerp; + //glerp = 1.f - glerp; + //blerp = 1.f - blerp; + + rlerp = 1 / rlerp; + glerp = 1 / glerp; + blerp = 1 / blerp; + + glm::vec3 idxlst(rlerp, glerp, blerp); + + int largeidx = 0; + if (rlerp > glerp) + largeidx = 0; + else + largeidx = 1; + if (idxlst[largeidx] > blerp) + largeidx = largeidx; + else + largeidx = 2; + + //rlerp *= rlerp; + //glerp *= glerp; + //blerp *= blerp; + + + + float N = 200.f; + glm::vec3 Albedored(1, 0, 0); glm::vec3 Albedogreen(0, 1, 0); glm::vec3 Albedoblue(0, 0, 1); + glm::vec3 dispersionAlbedo = (1 / N)*(rlerp*Albedored + glerp*Albedogreen + blerp*Albedoblue); + + + if (rand < 0.5) + actualcol = 1.2f*glm::vec3(largeidx == 0 ? 1 : 0, largeidx == 1 ? 1 : 0, largeidx == 2 ? 1 : 0); + else + actualcol *= 1.1f; + + //glm::clamp(actualcol, glm::vec3(0), glm::vec3(1)); + + float indexRatio; + float theta = (180.0f / PI) * acos(glm::dot(pathSegment.ray.direction, normal) /*/ (glm::length(pathSegment.ray.direction) * glm::length(normal))*/); + bool in = true; + if (theta >= 90.0f) { + + indexRatio = 1.f / actualidx /*m.indexOfRefraction*/; + } + else + { + //in = true; + indexRatio = actualidx/*m.indexOfRefraction*/; + } + float R0in = (1 - actualidx) / (1 + actualidx) * (1 - actualidx) / (1 + actualidx); + float RSchlickin = R0in + (1.0f - R0in) * glm::pow(1.0f - glm::abs(glm::dot(normal, pathSegment.ray.direction)), 5); + + float R0 = (1 - indexRatio) / (1 + indexRatio) * (1 - indexRatio) / (1 + indexRatio); + float RSchlick = R0 + (1.0f - R0) * glm::pow(1.0f - glm::abs(glm::dot(normal, pathSegment.ray.direction)), 5); + if (in) + { + if (RSchlick < rand) + { + pathSegment.ray.direction = glm::normalize(glm::refract(pathSegment.ray.direction, normal, indexRatio)); + pathSegment.color *= actualcol*m.color;/*m.color * m.specular.color*/ + } + else + { + pathSegment.ray.direction = glm::normalize(glm::reflect(pathSegment.ray.direction, normal)); + pathSegment.color *= 1.f*m.color; + } + } + else + { + if (RSchlickin < rand) + { + pathSegment.ray.direction = glm::normalize(glm::refract(pathSegment.ray.direction, normal, indexRatio)); + pathSegment.color *= actualcol*m.color;/*m.color * m.specular.color*/ + } + else + { + pathSegment.ray.direction = glm::normalize(glm::reflect(pathSegment.ray.direction, -normal)); + pathSegment.color *= 1.f*m.color; + } + } + pathSegment.ray.origin = intersect + 1e-3f * (glm::normalize(pathSegment.ray.direction)); + + pathSegment.remainingBounces--; + } + + else + { + pathSegment.remainingBounces--; + pathSegment.ray.direction = calculateRandomDirectionInHemisphere(normal, rng); + pathSegment.ray.origin = intersect+0.001f*normal; + pathSegment.color *= m.color; + } } diff --git a/src/intersections.h b/src/intersections.h index 6f23872..f6a366a 100644 --- a/src/intersections.h +++ b/src/intersections.h @@ -2,10 +2,13 @@ #include #include +#include #include "sceneStructs.h" #include "utilities.h" +#include + /** * Handy-dandy hash function that provides seeds for random number generation. */ @@ -28,13 +31,279 @@ __host__ __device__ glm::vec3 getPointOnRay(Ray r, float t) { return r.origin + (t - .0001f) * glm::normalize(r.direction); } +__host__ __device__ glm::vec3 multiplyMV(glm::mat4 m, glm::vec4 v) { + return glm::vec3(m * v); +} + +__host__ __device__ bool aabbBoxIntersectKD(const Ray& r, glm::vec3 min, glm::vec3 max,float& near) +{ + float tnear = FLT_MIN; + float tfar = FLT_MAX; + + for (int i = 0; i<3; i++) + { + float t0, t1; + + if (fabs(r.direction[i]) < EPSILON) + { + if (r.origin[i] < min[i] || r.origin[i] > max[i]) + return false; + else + { + t0 = FLT_MIN; + t1 = FLT_MAX; + } + } + else + { + t0 = (min[i] - r.origin[i]) / r.direction[i]; + t1 = (max[i] - r.origin[i]) / r.direction[i]; + } + + tnear = glm::max(tnear, glm::min(t0, t1)); + tfar = glm::min(tfar, glm::max(t0, t1)); + } + + if (tfar < tnear) return false; // no intersection + + if (tfar < 0) return false; // behind origin of ray + + near = tnear; + + return true; + +} + +__host__ __device__ bool aabbBoxIntersectlocal(Geom meshgeom,const Ray& r, glm::vec3 min, glm::vec3 max) +{ + + Ray q; + q.origin = multiplyMV(meshgeom.inverseTransform, glm::vec4(r.origin, 1.0f)); + q.direction = glm::normalize(multiplyMV(meshgeom.inverseTransform, glm::vec4(r.direction, 0.0f))); + + float tnear = FLT_MIN; + float tfar = FLT_MAX; + + for (int i = 0; i<3; i++) + { + float t0, t1; + + if (fabs(q.direction[i]) < EPSILON) + { + if (q.origin[i] < min[i] || q.origin[i] > max[i]) + return false; + else + { + t0 = FLT_MIN; + t1 = FLT_MAX; + } + } + else + { + t0 = (min[i] - q.origin[i]) / q.direction[i]; + t1 = (max[i] - q.origin[i]) / q.direction[i]; + } + + tnear = glm::max(tnear, glm::min(t0, t1)); + tfar = glm::min(tfar, glm::max(t0, t1)); + } + + if (tfar < tnear) return false; // no intersection + + if (tfar < 0) return false; // behind origin of ray + + return true; + +} + +__host__ __device__ bool aabbBoxIntersect(const Ray& r, glm::vec3 min, glm::vec3 max) +{ + float tnear = FLT_MIN; + float tfar = FLT_MAX; + + for (int i = 0; i<3; i++) + { + float t0, t1; + + if (fabs(r.direction[i]) < EPSILON) + { + if (r.origin[i] < min[i] || r.origin[i] > max[i]) + return false; + else + { + t0 = FLT_MIN; + t1 = FLT_MAX; + } + } + else + { + t0 = (min[i] - r.origin[i]) / r.direction[i]; + t1 = (max[i] - r.origin[i]) / r.direction[i]; + } + + tnear = glm::max(tnear, glm::min(t0, t1)); + tfar = glm::min(tfar, glm::max(t0, t1)); + } + + if (tfar < tnear) return false; // no intersection + + if (tfar < 0) return false; // behind origin of ray + + return true; + +} + + +__host__ __device__ bool KDtreeintersectBB(Ray r, glm::vec3 mins, glm::vec3 maxs, float& dist) +{ + + bool result = false; + glm::vec3 invdir(1.0f / r.direction.x, + 1.0f / r.direction.y, + 1.0f / r.direction.z); + + float v1 = (mins[0] - r.origin.x)*invdir.x; + float v2 = (maxs[0] - r.origin.x)*invdir.x; + float v3 = (mins[1] - r.origin.y)*invdir.y; + float v4 = (maxs[1] - r.origin.y)*invdir.y; + float v5 = (mins[2] - r.origin.z)*invdir.z; + float v6 = (maxs[2] - r.origin.z)*invdir.z; + + float dmin = max(max(min(v1, v2), min(v3, v4)), min(v5, v6)); + float dmax = min(min(max(v1, v2), max(v3, v4)), max(v5, v6)); + + if (dmax < 0) + { + dist = dmax; + result = false; + return result; + } + if (dmin > dmax) + { + dist = dmax; + result = false; + return result; + } + dist = dmin; + result = true; + return result; +} +__host__ __device__ bool KDhit(Geom meshgeom + , GPUKDtreeNode* nodelst + , Ray& r + , int& startidx + , int& endidx + , int* gputrilst + , int& size + +) +{ + if (!nodelst) return false; + Ray q; + q.origin = multiplyMV(meshgeom.inverseTransform, glm::vec4(r.origin, 1.0f)); + q.direction = glm::normalize(multiplyMV(meshgeom.inverseTransform, glm::vec4(r.direction, 0.0f))); + int curnodeidx = 0; + int count = 0; + GPUKDtreeNode* node = NULL; + bool nodeIDs[100] = { false }; + while (count<6) + { + node = &nodelst[curnodeidx]; + float near1 = 0, near2 = 0; + bool lefthit = false; + bool righthit = false; + if(node->leftidx!=-1) + lefthit = aabbBoxIntersectKD(q, nodelst[node->leftidx].minB, nodelst[node->leftidx].maxB, near1); + if (node->rightidx != -1) + righthit = aabbBoxIntersectKD(q, nodelst[node->rightidx].minB, nodelst[node->rightidx].maxB, near2); + if (lefthit&&righthit&&node->trsize>1 && (node->leftidx != -1 && node->rightidx != -1)) + { + if (near1 < near2) curnodeidx = node->leftidx; + else curnodeidx = node->rightidx; + } + else if (lefthit&& node->trsize>1 && (node->leftidx != -1)) + { + curnodeidx = node->leftidx; + } + else if (righthit&&node->trsize>1 && (node->rightidx != -1)) + { + curnodeidx = node->rightidx; + } + else + { + continue; + } + count++; + } + if (count == 0) + return false; + else + { + startidx = node->GPUtriangleidxinLst; + endidx = startidx + node->trsize; + return true; + } +} + + + + + /** * Multiplies a mat4 and a vec4 and returns a vec3 clipped from the vec4. */ -__host__ __device__ glm::vec3 multiplyMV(glm::mat4 m, glm::vec4 v) { - return glm::vec3(m * v); -} + +__host__ __device__ float triangleIntersectionTest(Geom meshgeom, Ray r, + glm::vec3 &intersectionPoint, glm::vec3 &normal, bool &outside ,Triangle tri) +{ + Ray q; + q.origin = multiplyMV(meshgeom.inverseTransform, glm::vec4(r.origin, 1.0f)); + q.direction = glm::normalize(multiplyMV(meshgeom.inverseTransform, glm::vec4(r.direction, 0.0f))); + + glm::vec3 bary; + + float t = -1; + if (glm::intersectRayTriangle(q.origin, q.direction, tri.Triverts[0].pos, tri.Triverts[1].pos, tri.Triverts[2].pos, bary)) { + t = bary.z; + } + + glm::vec3 objspaceIntersection = getPointOnRay(q, t); + + intersectionPoint = multiplyMV(meshgeom.transform, glm::vec4(objspaceIntersection, 1.f)); + + normal = glm::normalize(glm::cross(tri.Triverts[0].pos - tri.Triverts[1].pos, tri.Triverts[0].pos - tri.Triverts[2].pos))/*tri.Trinormal*/; + normal = glm::normalize(multiplyMV(meshgeom.transform, glm::vec4(normal, 0.0f))); + outside = true; + + if (glm::dot(q.origin, normal) < 0) { + outside = false; + } + + return t; + /*float tmin = -1e38f; + float tmax = 1e38f; + glm::vec3 tmin_n; + glm::vec3 tmax_n; + + glm::vec3 res; + bool is_intersect = false; + + if (glm::dot(tri.Trinormal, q.direction) < 0) outside = true; + is_intersect= glm::intersectRayTriangle(q.origin, q.direction, tri.Triverts[0].pos, tri.Triverts[1].pos, tri.Triverts[2].pos, res); + + if (is_intersect) + { + + intersectionPoint = q.origin + q.direction*res.z; + normal = tri.Trinormal; + intersectionPoint = multiplyMV(meshgeom.transform, glm::vec4(intersectionPoint, 1.0f)); + normal = glm::normalize(multiplyMV(meshgeom.transform, glm::vec4(normal, 0.0f))); + return glm::length(r.origin - intersectionPoint); + } + + return -1;*/ +} // CHECKITOUT /** * Test intersection between a ray and a transformed cube. Untransformed, diff --git a/src/pathtrace.cu b/src/pathtrace.cu index c1ec122..33f2117 100644 --- a/src/pathtrace.cu +++ b/src/pathtrace.cu @@ -4,6 +4,9 @@ #include #include #include +#include +#include +#include #include "sceneStructs.h" #include "scene.h" @@ -14,8 +17,17 @@ #include "intersections.h" #include "interactions.h" + #define ERRORCHECK 1 +#define COMPACTION 1 +#define SORTBYMATERIAL 0 +#define CACHE 0 +#define ANTIALIASING 0 +//#define TOGGLEKD +#define DOFTOGGLE 0 +#define FULLLIGHT 1 + #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__) void checkCUDAErrorFn(const char *msg, const char *file, int line) { @@ -38,6 +50,25 @@ void checkCUDAErrorFn(const char *msg, const char *file, int line) { #endif } + +struct _test_bounce_ { + __host__ __device__ bool operator()(const PathSegment tmp) + { + bool have_bounce = false; + if (tmp.remainingBounces > 0) have_bounce = true; + return (have_bounce); + } +}; + +struct _test_material_ +{ + __host__ __device__ bool operator()(const ShadeableIntersection _first, const ShadeableIntersection _second) + { + bool returnval = _first.materialId > _second.materialId ? false : true; + return returnval; + } +}; + __host__ __device__ thrust::default_random_engine makeSeededRandomEngine(int iter, int index, int depth) { int h = utilhash((1 << 31) | (depth << 22) | iter) ^ utilhash(index); @@ -72,7 +103,17 @@ static glm::vec3 * dev_image = NULL; static Geom * dev_geoms = NULL; static Material * dev_materials = NULL; static PathSegment * dev_paths = NULL; +static mesh * dev_meshs = NULL; +static Triangle * dev_triangles = NULL; static ShadeableIntersection * dev_intersections = NULL; +static ShadeableIntersection * dev_intersections_cache = NULL; +static GPUKDtreeNode *dev_KDtreenode = NULL; +static int *dev_gputriidxlst; +static int *dev_idxchecker; +static const int MAX_NODE_SIZE = 70000; + +//for dispersion wavelength +static float *dev_wavelen; // TODO: static variables for device memory, any extra info you need, etc // ... @@ -89,12 +130,37 @@ void pathtraceInit(Scene *scene) { cudaMalloc(&dev_geoms, scene->geoms.size() * sizeof(Geom)); cudaMemcpy(dev_geoms, scene->geoms.data(), scene->geoms.size() * sizeof(Geom), cudaMemcpyHostToDevice); + cudaMalloc(&dev_meshs, scene->meshs.size() * sizeof(mesh)); + cudaMemcpy(dev_meshs, scene->meshs.data(), scene->meshs.size() * sizeof(mesh), cudaMemcpyHostToDevice); + + cudaMalloc(&dev_triangles, scene->triangles.size() * sizeof(Triangle)); + cudaMemcpy(dev_triangles, scene->triangles.data(), scene->triangles.size() * sizeof(Triangle), cudaMemcpyHostToDevice); + cudaMalloc(&dev_materials, scene->materials.size() * sizeof(Material)); cudaMemcpy(dev_materials, scene->materials.data(), scene->materials.size() * sizeof(Material), cudaMemcpyHostToDevice); cudaMalloc(&dev_intersections, pixelcount * sizeof(ShadeableIntersection)); cudaMemset(dev_intersections, 0, pixelcount * sizeof(ShadeableIntersection)); + cudaMalloc(&dev_intersections_cache, pixelcount * sizeof(ShadeableIntersection)); + cudaMemset(dev_intersections_cache, 0, pixelcount * sizeof(ShadeableIntersection)); + + cudaMalloc(&dev_idxchecker, scene->KDtreeforGPU.size() * sizeof(int)); + + cudaMalloc(&dev_wavelen, pixelcount * sizeof(float)); + cudaMemcpy(dev_wavelen, scene->wavelen.data(), scene->wavelen.size() * sizeof(float), cudaMemcpyHostToDevice); +#ifdef TOGGLEKD + + + + cudaMalloc(&dev_KDtreenode, scene->KDtreeforGPU.size() * sizeof(GPUKDtreeNode)); + cudaMemcpy(dev_KDtreenode, scene->KDtreeforGPU.data(), scene->KDtreeforGPU.size() * sizeof(GPUKDtreeNode), cudaMemcpyHostToDevice); + + cudaMalloc(&dev_gputriidxlst, scene->triangleidxforGPU.size() * sizeof(int)); + cudaMemcpy(dev_gputriidxlst, scene->triangleidxforGPU.data(), scene->triangleidxforGPU.size() * sizeof(int), cudaMemcpyHostToDevice); + + +#endif // TOGGLEKD // TODO: initialize any extra device memeory you need checkCUDAError("pathtraceInit"); @@ -104,13 +170,54 @@ void pathtraceFree() { cudaFree(dev_image); // no-op if dev_image is null cudaFree(dev_paths); cudaFree(dev_geoms); + cudaFree(dev_meshs); + cudaFree(dev_triangles); cudaFree(dev_materials); cudaFree(dev_intersections); + cudaFree(dev_wavelen); +#ifdef TOGGLEKD + cudaFree(dev_KDtreenode); + cudaFree(dev_gputriidxlst); + +#endif + cudaFree(dev_idxchecker); // TODO: clean up any extra device memory you created checkCUDAError("pathtraceFree"); } - +//disksample code from https://pub.dartlang.org/documentation/dartray/0.0.1/core/ConcentricSampleDisk.html +__device__ __host__ glm::vec2 ConcentricSampleDisk(float rand_x, float rand_y) +{ + float r, theta; + float sx = 2 * rand_x - 1; + float sy = 2 * rand_y - 1; + if (sx == 0.0 && sy == 0.0) { + return glm::vec2(0.f); + } + if (sx >= -sy) { + if (sx > sy) { + r = sx; + if (sy > 0.0) theta = sy / r; + else theta = 8.0f + sy / r; + } + else { + r = sy; + theta = 2.0f - sx / r; + } + } + else { + if (sx <= sy) { + r = -sx; + theta = 4.0f - sy / r; + } + else { + r = -sy; + theta = 6.0f + sx / r; + } + } + theta *= PI / 4.f; + return glm::vec2(r * cosf(theta), r * sinf(theta)); +} /** * Generate PathSegments with rays from the camera through the screen into the * scene, which is the first bounce of rays. @@ -119,7 +226,7 @@ void pathtraceFree() { * motion blur - jitter rays "in time" * lens effect - jitter ray origin positions based on a lens */ -__global__ void generateRayFromCamera(Camera cam, int iter, int traceDepth, PathSegment* pathSegments) +__global__ void generateRayFromCamera(Camera cam, int iter, int traceDepth, PathSegment* pathSegments, float* wavelen) { int x = (blockIdx.x * blockDim.x) + threadIdx.x; int y = (blockIdx.y * blockDim.y) + threadIdx.y; @@ -129,19 +236,54 @@ __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 rng1 = makeSeededRandomEngine(iter, x, y); + thrust::default_random_engine rng = makeSeededRandomEngine(iter, x+(cam.resolution.x)*y, 0); + thrust::uniform_real_distribution u01(-0.5f, 0.5f); + thrust::uniform_real_distribution u02(0, 1.f); +#if ANTIALIASING == 1 // TODO: implement antialiasing by jittering the ray + segment.ray.direction = glm::normalize(cam.view + - 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 ) + ); +#else 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) - ); - + ); +#endif +#if DOFTOGGLE == 1 + float rand_x = u01(rng); + float rand_y = u01(rng); + float camlenrad = 0.6; + float focallen = 10; + glm::vec2 raysampled = camlenrad*ConcentricSampleDisk(rand_x, rand_y); + glm::vec3 physicallength = segment.ray.origin + glm::abs(focallen / segment.ray.direction.z)*segment.ray.direction; + segment.ray.origin = segment.ray.origin + raysampled.x*cam.right + raysampled.y*cam.up; + segment.ray.direction = glm::normalize(physicallength - segment.ray.origin); +#endif + segment.ray.wavelength = u01(rng1)+0.5f; segment.pixelIndex = index; segment.remainingBounces = traceDepth; } } +__global__ void ComputeBSDF( int num_paths + , PathSegment *pathSegments + , ShadeableIntersection *intersections ) +{ + int path_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (path_idx < num_paths) + { + if (intersections[path_idx].materialId == 0)//diffuse? + { + + } + } + +} + // TODO: // computeIntersections handles generating ray intersections ONLY. // Generating new rays is handled in your shader(s). @@ -153,6 +295,15 @@ __global__ void computeIntersections( , Geom * geoms , int geoms_size , ShadeableIntersection * intersections + , mesh* meshs + , Triangle* triangle1 +#ifdef TOGGLEKD + , GPUKDtreeNode* node + , int node_size + , int* gputrilst + , int trisize + , int* idxchecker +#endif ) { int path_index = blockIdx.x * blockDim.x + threadIdx.x; @@ -168,6 +319,7 @@ __global__ void computeIntersections( int hit_geom_index = -1; bool outside = true; + bool have_mesh = false; glm::vec3 tmp_intersect; glm::vec3 tmp_normal; @@ -176,6 +328,7 @@ __global__ void computeIntersections( for (int i = 0; i < geoms_size; i++) { Geom & geom = geoms[i]; + have_mesh = false; if (geom.type == CUBE) { @@ -185,16 +338,153 @@ __global__ void computeIntersections( { t = sphereIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside); } + else if (geom.type == MESH) + { + have_mesh = true; + if (geom.meshid != -1); + { +#ifdef TOGGLEKD + bool isTraversed[MAX_NODE_SIZE] = { false }; + mesh & Tempmesh = meshs[geom.meshid]; + glm::vec3 maxbound = Tempmesh.maxbound; + glm::vec3 minbound = Tempmesh.minbound; + if (!aabbBoxIntersectlocal(geom, pathSegment.ray, minbound, maxbound)) + { + t = -1; + continue; + } + bool hitgeom = false; + float near = -1; + GPUKDtreeNode* curnode = &node[0]; + int curid = 0; + float dis = FLT_MAX; + //idxchecker[0] = 1; + int count = 0; + while (curid!=-1) + { + curnode = &node[curid]; + bool lefthit = false; + bool righthit = false; + if(curnode->leftidx!=-1) + lefthit= KDtreeintersectBB(pathSegment.ray, node[curnode->leftidx].minB, node[curnode->leftidx].maxB, near); + if(curnode->rightidx!=-1) + righthit = KDtreeintersectBB(pathSegment.ray, node[curnode->rightidx].minB, node[curnode->rightidx].maxB, near); + if (!lefthit&&curnode->leftidx != -1) + { + isTraversed[curnode->leftidx] = true; + } + if (!righthit&&curnode->rightidx != -1) + { + isTraversed[curnode->rightidx] = true; + } + while (curnode->leftidx != -1 && isTraversed[curnode->leftidx] == false) + { + + curid = curnode->leftidx; + curnode = &node[curid]; + + } + if (!isTraversed[curid]) + { + isTraversed[curnode->curidx] = true; + if (curnode->isleafnode) + { + int size = curnode->trsize; + if (size > 0) + { + int start = curnode->GPUtriangleidxinLst; + int end = start + size; + for (int j = start; j < end; ++j) + { + int triidxnow = gputrilst[j]; + t = triangleIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, triangle1[triidxnow]); + dis = t; + if (t > 0.0f && t_min > t) + { + t_min = t; + hit_geom_index = i; + intersect_point = tmp_intersect; + normal = tmp_normal; + } + } + } + } + } + if (curnode->rightidx != -1 && isTraversed[curnode->rightidx] == false) + { + + curid = curnode->rightidx; + curnode = &node[curid]; + + } + else + { + curid = curnode->parentidx; + curnode = &node[curid]; + } + + + } + /*int startidx, endidx; + int size = 0; + bool ishit = KDhit(geom, node, pathSegment.ray, startidx, endidx, gputrilst, size); + if (ishit) + { + for (int j = startidx; j < endidx; ++j) + { + Triangle curTri = triangle1[gputrilst[j]]; + t = triangleIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside, curTri); + if (t > 0.0f && t_min > t) + { + t_min = t; + hit_geom_index = i; + intersect_point = tmp_intersect; + normal = tmp_normal; + } + } + + }*/ +#else + mesh & Tempmesh = meshs[geom.meshid]; + glm::vec3 maxbound = Tempmesh.maxbound; + glm::vec3 minbound = Tempmesh.minbound; + int startidx = meshs[geom.meshid].TriStartIndex; + int trisize = meshs[geom.meshid].TriSize; + if (!aabbBoxIntersectlocal(geom,pathSegment.ray, minbound, maxbound)) + { + t = -1; + continue; + } + for (int j = startidx; j < trisize + startidx; ++j) + { + Triangle & triii = triangle1[j]; + t = triangleIntersectionTest(geom, pathSegment.ray, tmp_intersect, tmp_normal, outside,triii); + if (t > 0.0f && t_min > t) + { + t_min = t; + hit_geom_index = i; + intersect_point = tmp_intersect; + normal = tmp_normal; + } + } + + +#endif + } + } // TODO: add more intersection tests here... triangle? metaball? CSG? // Compute the minimum t from the intersection tests to determine what // scene geometry object was hit first. - if (t > 0.0f && t_min > t) + if (!have_mesh) { - t_min = t; - hit_geom_index = i; - intersect_point = tmp_intersect; - normal = tmp_normal; + if (t > 0.0f && t_min > t) + { + t_min = t; + hit_geom_index = i; + intersect_point = tmp_intersect; + normal = tmp_normal; + } } } @@ -205,6 +495,7 @@ __global__ void computeIntersections( else { //The ray hits something + pathSegments[path_index].it = outside ? 0.f : t_min; intersections[path_index].t = t_min; intersections[path_index].materialId = geoms[hit_geom_index].materialid; intersections[path_index].surfaceNormal = normal; @@ -239,10 +530,8 @@ __global__ void shadeFakeMaterial ( // makeSeededRandomEngine as well. thrust::default_random_engine rng = makeSeededRandomEngine(iter, idx, 0); thrust::uniform_real_distribution u01(0, 1); - Material material = materials[intersection.materialId]; glm::vec3 materialColor = material.color; - // If the material indicates that the object was a light, "light" the ray if (material.emittance > 0.0f) { pathSegments[idx].color *= (materialColor * material.emittance); @@ -265,6 +554,44 @@ __global__ void shadeFakeMaterial ( } } +__global__ void shadeMaterial( + int iter + , int num_paths + , ShadeableIntersection * shadeableIntersections + , PathSegment * pathSegments + , Material * materials +) +{ + int idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx < num_paths) + { + ShadeableIntersection intersection = shadeableIntersections[idx]; + if (intersection.t > 0.0f) + { // if the intersection exists... + // Set up the RNG + // LOOK: this is how you use thrust's RNG! Please look at + // makeSeededRandomEngine as well. + thrust::default_random_engine rng = makeSeededRandomEngine(iter, idx, 0); + thrust::uniform_real_distribution u01(0, 1); + Material material = materials[intersection.materialId]; + glm::vec3 materialColor = material.color; + if (pathSegments[idx].remainingBounces > 0) + { + scatterRay(pathSegments[idx], intersection.t*pathSegments[idx].ray.direction+pathSegments[idx].ray.origin, intersection.surfaceNormal, materials[intersection.materialId], rng); + } + } + else + { +#if FULLLIGHT == 0 + pathSegments[idx].color = glm::vec3(0.0f); +#else + pathSegments[idx].color *= glm::vec3(0.1f,0.1f,0.1f); +#endif + 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 +604,15 @@ __global__ void finalGather(int nPaths, glm::vec3 * image, PathSegment * iterati } } +__global__ void initializechecker(int checknums, int* checker) +{ + int index = (blockIdx.x * blockDim.x) + threadIdx.x; + if (index < checknums) + { + checker[index] = -1; + } +} + /** * Wrapper for the __global__ call that sets up the kernel calls and does a ton * of memory management @@ -295,6 +631,8 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { // 1D block for path tracing const int blockSize1d = 128; + dim3 nums = (hst_scene->KDtreeforGPU.size() + blockSize1d - 1) / blockSize1d; + initializechecker << > >(hst_scene->KDtreeforGPU.size(),dev_idxchecker); /////////////////////////////////////////////////////////////////////////// // Recap: @@ -326,16 +664,19 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { // TODO: perform one iteration of path tracing - generateRayFromCamera <<>>(cam, iter, traceDepth, dev_paths); + generateRayFromCamera <<>>(cam, iter, traceDepth, dev_paths,dev_wavelen); checkCUDAError("generate camera ray"); int depth = 0; PathSegment* dev_path_end = dev_paths + pixelcount; int num_paths = dev_path_end - dev_paths; + int output_num_paths = num_paths; + // --- PathSegment Tracing Stage --- // Shoot ray into scene, bounce between objects, push shading chunks + int count = 0; bool iterationComplete = false; while (!iterationComplete) { @@ -344,17 +685,84 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { // tracing dim3 numblocksPathSegmentTracing = (num_paths + blockSize1d - 1) / blockSize1d; - computeIntersections <<>> ( +#if (CACHE ==1&&ANTIALIASING == 0&&DOFTOGGLE == 0) + if(iter==1&&depth==0) + { + computeIntersections << > > ( + depth + , num_paths + , dev_paths + , dev_geoms + , hst_scene->geoms.size() + , dev_intersections + , dev_meshs + , dev_triangles +#ifdef TOGGLEKD + , dev_KDtreenode + , hst_scene->KDtreeforGPU.size() + , dev_gputriidxlst + , hst_scene->triangles.size() + , dev_idxchecker +#endif + ); + cudaMemcpy(dev_intersections_cache, dev_intersections, pixelcount * sizeof(ShadeableIntersection), cudaMemcpyDeviceToDevice); + } + if (iter > 1 && depth == 0) + { + cudaMemcpy(dev_intersections, dev_intersections_cache, pixelcount * sizeof(ShadeableIntersection), cudaMemcpyDeviceToDevice); + } + else + { + if (depth > 0) + { + computeIntersections << > > ( + depth + , num_paths + , dev_paths + , dev_geoms + , hst_scene->geoms.size() + , dev_intersections + , dev_meshs + , dev_triangles +#ifdef TOGGLEKD + , dev_KDtreenode + , hst_scene->KDtreeforGPU.size() + , dev_gputriidxlst + , hst_scene->triangles.size() + , dev_idxchecker +#endif + ); + } + } +#else + computeIntersections << > > ( depth , num_paths , dev_paths , dev_geoms , hst_scene->geoms.size() , dev_intersections + , dev_meshs + , dev_triangles +#ifdef TOGGLEKD + , dev_KDtreenode + , hst_scene->KDtreeforGPU.size() + , dev_gputriidxlst + , hst_scene->triangles.size() + , dev_idxchecker +#endif ); +#endif checkCUDAError("trace one bounce"); cudaDeviceSynchronize(); depth++; + + //SORT dev_paths and dev_intersections by material id, don't toggle on unless number of materials is large, or it would slow the program down. +#if SORTBYMATERIAL == 1 + + thrust::sort_by_key(thrust::device,dev_intersections, dev_intersections + num_paths, dev_paths, _test_material_()); + +#endif // SORTBYMATERIAL // TODO: @@ -366,19 +774,42 @@ void pathtrace(uchar4 *pbo, int frame, int iter) { // TODO: compare between directly shading the path segments and shading // path segments that have been reshuffled to be contiguous in memory. - shadeFakeMaterial<<>> ( + shadeMaterial<<>> ( iter, num_paths, dev_intersections, dev_paths, dev_materials ); - iterationComplete = true; // TODO: should be based off stream compaction results. + //compaction pathsegments using thrust's partition +#if COMPACTION==1 + + PathSegment *_iter_second_begin_ = thrust::partition(thrust::device, dev_paths, dev_paths + num_paths, _test_bounce_()); + num_paths = _iter_second_begin_ - dev_paths; + + + if (num_paths > 0) + continue; + else + iterationComplete = true; + +#endif + + +#if COMPACTION==1 + +#elif COMPACTION==0 + count ++ ; + if(count>8) + iterationComplete = true; +#endif + + // TODO: should be based off stream compaction results. } // Assemble this iteration and apply it to the image - dim3 numBlocksPixels = (pixelcount + blockSize1d - 1) / blockSize1d; - finalGather<<>>(num_paths, dev_image, dev_paths); + dim3 numBlocksPixels = (pixelcount + blockSize1d - 1) / blockSize1d; + finalGather<<>>(output_num_paths, dev_image, dev_paths); /////////////////////////////////////////////////////////////////////////// diff --git a/src/scene.cpp b/src/scene.cpp index cbae043..50da42f 100644 --- a/src/scene.cpp +++ b/src/scene.cpp @@ -4,7 +4,13 @@ #include #include +#define TINYOBJLOADER_IMPLEMENTATION +#include "tiny_obj_loader.h" + + + Scene::Scene(string filename) { + meshcount = 0; cout << "Reading scene from " << filename << " ..." << endl; cout << " " << endl; char* fname = (char*)filename.c_str(); @@ -30,8 +36,69 @@ Scene::Scene(string filename) { } } } + wavelen.resize(state.camera.resolution.x*state.camera.resolution.y); + for (int i = 0; i < wavelen.size(); ++i) + { + wavelen[i] = (rand() % 1000) / 1000.f; + } + buildKDtree(); +} + + +bool Scene::buildKDtree() +{ + cout << "Start building KD tree .... .... " << endl; + rootnode->Build(rootnode,triangles, 0,nodecount,NULL); + cout << "KD tree build finised" << endl; + int cc = 0; + BuildTreeGPU(rootnode, 0); + return 1; +} + + + +void Scene::BuildTreeGPU(KDtreeNode* nn,int cc) +{ + + if (nn!=NULL/*&&nn->triangles.size()!=0*/) + { + + GPUKDtreeNode tmpnode; + + tmpnode.GPUtriangleidxinLst = triangleidxforGPU.size(); + tmpnode.trsize = nn->triangles.size(); + tmpnode.curidx = nn->nodeidx; + for (int i = 0; i < nn->triangles.size(); ++i) + { + triangleidxforGPU.push_back(nn->triangles[i].triidx); + } + if (nn->parent != NULL) + { + tmpnode.parentidx = nn->parent->nodeidx; + } + if (nn->left != NULL) + tmpnode.leftidx = nn->left->nodeidx; + if (nn->right != NULL) + tmpnode.rightidx = nn->right->nodeidx; + tmpnode.depth = nn->depth; + tmpnode.maxB = nn->BoundingBox.maxB; + tmpnode.minB = nn->BoundingBox.minB; + if (nn->left == NULL&&nn->right == NULL) tmpnode.isleafnode = true; + if (nn->left == NULL) tmpnode.leftidx = -1; + if (nn->right == NULL) tmpnode.rightidx = -1; + KDtreeforGPU.push_back(tmpnode); + if (nn->left != NULL) + { + BuildTreeGPU(nn->left, tmpnode.curidx + 1); + } + if (nn->right != NULL) + { + BuildTreeGPU(nn->right, tmpnode.curidx + 2); + } + } } + int Scene::loadGeom(string objectid) { int id = atoi(objectid.c_str()); if (id != geoms.size()) { @@ -52,8 +119,81 @@ int Scene::loadGeom(string objectid) { cout << "Creating new cube..." << endl; newGeom.type = CUBE; } + else if (strcmp(line.c_str(), "mesh") == 0) + { + //load obj file + + mesh newmesh; + cout << "Building mesh..." << endl; + newGeom.type = MESH; + newGeom.meshid = meshcount; + newmesh.TriStartIndex = triangles.size(); + string objfiledir; + utilityCore::safeGetline(fp_in, line); + objfiledir = line; + cout << "Loading obj from" << objfiledir << endl; + std::vector shapes; + std::vector mats; + string error; + tinyobj::attrib_t attr; + bool success = tinyobj::LoadObj(&attr, &shapes, &mats, &error, objfiledir.c_str()); + if (!success) return -1; + if (!error.empty()) cout << "Error loading obj" << error << endl; + cout << "load obj success" << endl; + int tricount = 0; + float maxx = 1e+8; float maxy = 1e+8; float maxz = 1e+8; + float minx = -(1e+8); float miny = -(1e+8); float minz = -(1e+8); + for (int i = 0; i < shapes.size(); ++i) + { + for (int j = 0; j < shapes[i].mesh.indices.size() / 3; ++j) + { + glm::vec3 maxB(-(1e+8)),minB(1e+8); + Triangle Trii; + glm::vec3 avgn(0); + for (int k = 0; k < 3; ++k) + { + int idxi = shapes[i].mesh.indices[3 * j + k].vertex_index; + int idxn = shapes[i].mesh.indices[3 * j + k].normal_index; + Trii.Triverts[k].pos = glm::vec3(attr.vertices[3 * idxi], attr.vertices[3 * idxi + 1], attr.vertices[3 * idxi + 2]); + glm::vec3 curpos = Trii.Triverts[k].pos; + + maxB.x = maxB.x < curpos.x ? curpos.x : maxB.x; + maxB.y = maxB.y < curpos.y ? curpos.y : maxB.y; + maxB.z = maxB.z < curpos.z ? curpos.z : maxB.z; + + minB.x = minB.x > curpos.x ? curpos.x : minB.x; + minB.y = minB.y > curpos.y ? curpos.y : minB.y; + minB.z = minB.z > curpos.z ? curpos.z : minB.z; + + maxx = maxx < curpos.x ? curpos.x : maxx; + maxy = maxy < curpos.y ? curpos.y : maxy; + maxz = maxz < curpos.z ? curpos.z : maxz; + + minx = minx > curpos.x ? curpos.x : minx; + miny = miny > curpos.y ? curpos.y : miny; + minz = minz > curpos.z ? curpos.z : minz; + + Trii.Triverts[k].normal = glm::vec3(attr.normals[3 * idxn], attr.normals[3 * idxn + 1], attr.normals[3 * idxn + 2]); + avgn += Trii.Triverts[k].normal; + } + Trii.BoundingBox.maxB = maxB; + Trii.BoundingBox.minB = minB; + Trii.Trinormal = avgn / 3.0f; + Trii.triidx = globaltricount; + tricount++; + triangles.push_back(Trii); + globaltricount++; + } + } + newmesh.maxbound = glm::vec3(maxx, maxy, maxz); + newmesh.minbound = glm::vec3(minx, miny, minz); + newmesh.TriSize = tricount; + meshs.push_back(newmesh); + meshcount++; + } } + //link material utilityCore::safeGetline(fp_in, line); if (!line.empty() && fp_in.good()) { @@ -160,7 +300,7 @@ int Scene::loadMaterial(string materialid) { Material newMaterial; //load static properties - for (int i = 0; i < 7; i++) { + for (int i = 0; i < 8; i++) { string line; utilityCore::safeGetline(fp_in, line); vector tokens = utilityCore::tokenizeString(line); @@ -180,7 +320,10 @@ 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(), "DIFFUSE") == 0) { + newMaterial.diffuse = atoi(tokens[1].c_str()); + } } materials.push_back(newMaterial); return 1; diff --git a/src/scene.h b/src/scene.h index f29a917..cd34203 100644 --- a/src/scene.h +++ b/src/scene.h @@ -8,19 +8,51 @@ #include "utilities.h" #include "sceneStructs.h" +#include"KDtreeNode.h" + + using namespace std; + +struct GPUKDtreeNode { + int leftidx; + int rightidx; + int depth; + int GPUtriangleidxinLst; + int trsize = 0; + int curidx; + int parentidx = -1; + bool isleafnode = false; + glm::vec3 maxB; + glm::vec3 minB; +}; + class Scene { private: ifstream fp_in; int loadMaterial(string materialid); int loadGeom(string objectid); int loadCamera(); + bool buildKDtree(); public: Scene(string filename); ~Scene(); + int globaltricount = 0; + int nodecount = -1; + + + void BuildTreeGPU(KDtreeNode* nn,int cc); + KDtreeNode *rootnode = new KDtreeNode(); + int meshcount; + std::vector meshs; std::vector geoms; + std::vector triangles; std::vector materials; + + std::vector triangleidxforGPU; + std::vector KDtreeforGPU; + std::vector wavelen; + RenderState state; }; diff --git a/src/sceneStructs.h b/src/sceneStructs.h index b38b820..01eced6 100644 --- a/src/sceneStructs.h +++ b/src/sceneStructs.h @@ -10,16 +10,19 @@ enum GeomType { SPHERE, CUBE, + MESH, }; struct Ray { glm::vec3 origin; glm::vec3 direction; + float wavelength; }; struct Geom { enum GeomType type; int materialid; + int meshid = -1; glm::vec3 translation; glm::vec3 rotation; glm::vec3 scale; @@ -38,6 +41,7 @@ struct Material { float hasRefractive; float indexOfRefraction; float emittance; + int diffuse; }; struct Camera { @@ -58,12 +62,50 @@ struct RenderState { std::vector image; std::string imageName; }; +struct Vertex +{ + glm::vec3 pos; + glm::vec3 normal; + glm::vec2 texcoord; + Vertex() {}; + Vertex(glm::vec3 ipos, glm::vec3 inormal) :pos(ipos), normal(inormal) { texcoord = glm::vec2(0); }; + Vertex(glm::vec3 ipos, glm::vec3 inormal, glm::vec2 itexcoord) :pos(ipos), normal(inormal), texcoord(itexcoord) {}; +}; + +struct Triangle +{ + int triidx; + Triangle() {}; + Vertex Triverts[3]; + glm::vec3 Trinormal; + struct + { + glm::vec3 maxB; + glm::vec3 minB; + }BoundingBox; + glm::vec3 computeMidpt() { + return (BoundingBox.maxB + BoundingBox.minB) / 2.f; + } + inline bool operator == (Triangle comp) + { + return (triidx == comp.triidx); + } +}; + +struct mesh { + int TriStartIndex; + int TriSize; + glm::vec3 maxbound; + glm::vec3 minbound; +}; + struct PathSegment { Ray ray; glm::vec3 color; int pixelIndex; int remainingBounces; + float it; }; // Use with a corresponding PathSegment to do: diff --git a/src/tiny_obj_loader.h b/src/tiny_obj_loader.h new file mode 100644 index 0000000..0ecb3df --- /dev/null +++ b/src/tiny_obj_loader.h @@ -0,0 +1,2557 @@ +/* +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 \ No newline at end of file diff --git a/stream_compaction/CMakeLists.txt b/stream_compaction/CMakeLists.txt index ac358c9..3a3d54c 100644 --- a/stream_compaction/CMakeLists.txt +++ b/stream_compaction/CMakeLists.txt @@ -3,5 +3,5 @@ set(SOURCE_FILES cuda_add_library(stream_compaction ${SOURCE_FILES} - OPTIONS -arch=sm_20 + OPTIONS -arch=sm_60 )