std::array<double, 3> values;

values[0] = double(diffuse[0]);

values[1] = double(diffuse[1]);

values[2] = double(diffuse[2]);

return values;

std::array<double, 3> values;

values[0] = double(specular[0]);

values[1] = double(specular[1]);

values[2] = double(specular[2]);

return values;

std::array<double, 3> values;

values[0] = double(transmittance[0]);

values[1] = double(transmittance[1]);

values[2] = double(transmittance[2]);

return values;

std::array<double, 3> values;

values[0] = double(emission[0]);

values[1] = double(emission[1]);

values[2] = double(emission[2]);

return values;

std::array<double, 3> values;

values[0] = double(ambient[0]);

values[1] = double(ambient[1]);

values[2] = double(ambient[2]);

return values;

diffuse[0] = real_t(a[0]);

diffuse[1] = real_t(a[1]);

diffuse[2] = real_t(a[2]);

ambient[0] = real_t(a[0]);

ambient[1] = real_t(a[1]);

ambient[2] = real_t(a[2]);

specular[0] = real_t(a[0]);

specular[1] = real_t(a[1]);

specular[2] = real_t(a[2]);

transmittance[0] = real_t(a[0]);

transmittance[1] = real_t(a[1]);

transmittance[2] = real_t(a[2]);

std::map<std::string, std::string>::const_iterator it =

unknown_parameter.find(key);

if (it != unknown_parameter.end()) {

return it->second;

}

return std::string();

std::vector<real_t> vertices; // 'v'(xyz)

// For backward compatibility, we store vertex weight in separate array.

std::vector<real_t> vertex_weights; // 'v'(w)

std::vector<real_t> normals; // 'vn'

std::vector<real_t> texcoords; // 'vt'(uv)

// For backward compatibility, we store texture coordinate 'w' in separate

// array.

std::vector<real_t> texcoord_ws; // 'vt'(w)

std::vector<real_t> colors; // extension: vertex colors

attrib_t() {}

//

// For pybind11

//

const std::vector<real_t> &GetVertices() const { return vertices; }

const std::vector<real_t> &GetVertexWeights() const { return vertex_weights; }

// 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) {}

public:

MaterialReader() {}

virtual ~MaterialReader();

virtual bool operator()(const std::string &matId,

std::vector<material_t> *materials,

std::map<std::string, int> *matMap, std::string *warn,

std::string *err) = 0;

public:

explicit MaterialFileReader(const std::string &mtl_basedir)

: m_mtlBaseDir(mtl_basedir) {}

virtual ~MaterialFileReader() {}

virtual bool operator()(const std::string &matId,

std::vector<material_t> *materials,

std::map<std::string, int> *matMap, std::string *warn,

std::string *err);

private:

std::string m_mtlBaseDir;

public:

explicit MaterialStreamReader(std::istream &inStream)

: m_inStream(inStream) {}

virtual ~MaterialStreamReader() {}

virtual bool operator()(const std::string &matId,

std::vector<material_t> *materials,

std::map<std::string, int> *matMap, std::string *warn,

std::string *err);

private:

std::istream &m_inStream;

bool triangulate; // triangulate polygon?

/// Parse vertex color.

/// If vertex color is not present, its filled with default value.

/// false = no vertex color

/// This will increase memory of parsed .obj

bool vertex_color;

///

/// Search path to .mtl file.

/// Default = "" = search from the same directory of .obj file.

/// Valid only when loading .obj from a file.

///

std::string mtl_search_path;

///

/// Use multithreaded parser(C++11 required).

/// Please keep in mind that multithreaded parser has limited support of parsing feature

/// compared to serialized(default) parser.

/// Also `TINYOBJLOADER_ENABLE_THREADED` must be defined.

///

bool threaded;

ObjReaderConfig() : triangulate(true), vertex_color(true), threaded(false) {}

public:

ObjReader() : valid_(false) {}

~ObjReader() {}

///

/// Load .obj and .mtl from a file.

///

/// @param[in] filename wavefront .obj filename

/// @param[in] config Reader configuration

///

bool ParseFromFile(const std::string &filename,

const ObjReaderConfig &config = ObjReaderConfig());

///

/// Parse .obj from a text string.

/// Need to supply .mtl text string by `mtl_text`.

/// This function ignores `mtllib` line in .obj text.

///

/// @param[in] obj_text wavefront .obj filename

/// @param[in] mtl_text wavefront .mtl filename

/// @param[in] config Reader configuration

///

bool ParseFromString(const std::string &obj_text, const std::string &mtl_text,

const ObjReaderConfig &config = ObjReaderConfig());

///

/// .obj was loaded or parsed correctly.

///

bool Valid() const { return valid_; }

const attrib_t &GetAttrib() const { return attrib_; }

const std::vector<shape_t> &GetShapes() const { return shapes_; }

const std::vector<material_t> &GetMaterials() const { return materials_; }

///

/// Warning message(may be filled after `Load` or `Parse`)

///

const std::string &Warning() const { return warning_; }

///

/// Error message(filled when `Load` or `Parse` failed)

///

const std::string &Error() const { return error_; }

private:

bool valid_;

attrib_t attrib_;

std::vector<shape_t> shapes_;

std::vector<material_t> materials_;

std::string warning_;

std::string error_;

public:

typedef typename std::allocator<T>::pointer pointer;

typedef typename std::allocator<T>::size_type size_type;

// Backing store for the allocator. The container owner is responsible for

// maintaining this for as long as any containers using this allocator are

// live.

struct Source {

Source() : used_stack_buffer_(false) {}

// Casts the buffer in its right type.

T *stack_buffer() { return reinterpret_cast<T *>(stack_buffer_); }

const T *stack_buffer() const {

return reinterpret_cast<const T *>(stack_buffer_);

}

//

// IMPORTANT: Take care to ensure that stack_buffer_ is aligned

// since it is used to mimic an array of T.

// Be careful while declaring any unaligned types (like bool)

// before stack_buffer_.

//

// The buffer itself. It is not of type T because we don't want the

// constructors and destructors to be automatically called. Define a POD

// buffer of the right size instead.

char stack_buffer_[sizeof(T[stack_capacity])];

// Set when the stack buffer is used for an allocation. We do not track

// how much of the buffer is used, only that somebody is using it.

bool used_stack_buffer_;

};

// Used by containers when they want to refer to an allocator of type U.

template <typename U>

struct rebind {

typedef StackAllocator<U, stack_capacity> other;

};

// For the straight up copy c-tor, we can share storage.

StackAllocator(const StackAllocator<T, stack_capacity> &rhs)

: source_(rhs.source_) {}

// ISO C++ requires the following constructor to be defined,

// and std::vector in VC++2008SP1 Release fails with an error

// in the class _Container_base_aux_alloc_real (from <xutility>)

// if the constructor does not exist.

// For this constructor, we cannot share storage; there's

// no guarantee that the Source buffer of Ts is large enough

// for Us.

// TODO(Google): If we were fancy pants, perhaps we could share storage

// iff sizeof(T) == sizeof(U).

template <typename U, size_t other_capacity>

StackAllocator(const StackAllocator<U, other_capacity> &other)

: source_(NULL) {

(void)other;

}

explicit StackAllocator(Source *source) : source_(source) {}

// Actually do the allocation. Use the stack buffer if nobody has used it yet

// and the size requested fits. Otherwise, fall through to the standard

// allocator.

pointer allocate(size_type n, void *hint = 0) {

if (source_ != NULL && !source_->used_stack_buffer_ &&

n <= stack_capacity) {

source_->used_stack_buffer_ = true;

return source_->stack_buffer();

} else {

return std::allocator<T>::allocate(n, hint);

}

}

// Free: when trying to free the stack buffer, just mark it as free. For

// non-stack-buffer pointers, just fall though to the standard allocator.

void deallocate(pointer p, size_type n) {

if (source_ != NULL && p == source_->stack_buffer())

source_->used_stack_buffer_ = false;

else

std::allocator<T>::deallocate(p, n);

}

private:

Source *source_;

public:

typedef TContainerType ContainerType;

typedef typename ContainerType::value_type ContainedType;

typedef StackAllocator<ContainedType, stack_capacity> Allocator;

// Allocator must be constructed before the container!

StackContainer() : allocator_(&stack_data_), container_(allocator_) {

// Make the container use the stack allocation by reserving our buffer size

// before doing anything else.

container_.reserve(stack_capacity);

}

// Getters for the actual container.

//

// Danger: any copies of this made using the copy constructor must have

// shorter lifetimes than the source. The copy will share the same allocator

// and therefore the same stack buffer as the original. Use std::copy to

// copy into a "real" container for longer-lived objects.

ContainerType &container() { return container_; }

const ContainerType &container() const { return container_; }

// Support operator-> to get to the container. This allows nicer syntax like:

// StackContainer<...> foo;

// std::sort(foo->begin(), foo->end());

ContainerType *operator->() { return &container_; }

const ContainerType *operator->() const { return &container_; }

#ifdef UNIT_TEST

// Retrieves the stack source so that that unit tests can verify that the

// buffer is being used properly.

const typename Allocator::Source &stack_data() const { return stack_data_; }

#endif

protected:

typename Allocator::Source stack_data_;

unsigned char pad_[7];

Allocator allocator_;

ContainerType container_;

// DISALLOW_EVIL_CONSTRUCTORS(StackContainer);

StackContainer(const StackContainer &);

void operator=(const StackContainer &);

: public StackContainer<std::vector<T, StackAllocator<T, stack_capacity> >,

stack_capacity> {

public:

StackVector()

: StackContainer<std::vector<T, StackAllocator<T, stack_capacity> >,

stack_capacity>() {}

// We need to put this in STL containers sometimes, which requires a copy

// constructor. We can't call the regular copy constructor because that will

// take the stack buffer from the original. Here, we create an empty object

// and make a stack buffer of its own.

StackVector(const StackVector<T, stack_capacity> &other)

: StackContainer<std::vector<T, StackAllocator<T, stack_capacity> >,

stack_capacity>() {

this->container().assign(other->begin(), other->end());

}

StackVector<T, stack_capacity> &operator=(

const StackVector<T, stack_capacity> &other) {

this->container().assign(other->begin(), other->end());

return *this;

}

// Vectors are commonly indexed, which isn't very convenient even with

// operator-> (using "->at()" does exception stuff we don't want).

T &operator[](size_t i) { return this->container().operator[](i); }

const T &operator[](size_t i) const {

return this->container().operator[](i);

}

int vertex_index, texcoord_index, normal_index;

index_t() : vertex_index(-1), texcoord_index(-1), normal_index(-1) {}

explicit index_t(int idx)

: vertex_index(idx), texcoord_index(idx), normal_index(idx) {}

index_t(int vidx, int vtidx, int vnidx)

: vertex_index(vidx), texcoord_index(vtidx), normal_index(vnidx) {}

while ((*token)[0] == ' ' || (*token)[0] == '\t') {

(*token)++;

}

while ((*token)[0] == ' ' || (*token)[0] == '\t' || (*token)[0] == '\r') {

(*token)++;

}

const char *p = token;

while (p[0] != '\0' && p[0] != ' ' && p[0] != '\t' && p[0] != '\r') {

p++;

}

return p - token;

int len = 0;

// Assume token[n-1] = '\0'

for (len = 0; len < n - 1; len++) {

if (token[len] == '\n') {

break;

}

if ((token[len] == '\r') && ((len < (n - 2)) && (token[len + 1] != '\n'))) {

break;

}

}

return len;

int value = 0;

int sign = 1;

if (*c == '+' || *c == '-') {

if (*c == '-') sign = -1;

c++;

}

while (((*c) >= '0') && ((*c) <= '9')) { // isdigit(*c)

value *= 10;

value += (int)(*c - '0');

c++;

}

return value * sign;

if (idx > 0) return idx - 1;

if (idx == 0) return 0;

return n + idx; // negative value = relative

index_t vi(