Full Reference

class nvisii.CameraVector(*args)

Proxy of C++ std::vector< nvisii::Camera * > class.

append(self, x): x: std::vector< nvisii::Camera * >::value_type

assign(self, n, x): n: std::vector< nvisii::Camera * >::size_type x: std::vector< nvisii::Camera * >::value_type

back(self) → camera

begin(self) → std::vector< nvisii::Camera * >::iterator

capacity(self) → std::vector< nvisii::Camera * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Camera * >::iterator

erase(self, pos) → std::vector< nvisii::Camera * >::iterator

pos: std::vector< nvisii::Camera * >::iterator

erase(self, first, last) -> std::vector< nvisii::Camera * >::iterator

first: std::vector< nvisii::Camera * >::iterator last: std::vector< nvisii::Camera * >::iterator

front(self) → camera

get_allocator(self) → std::vector< nvisii::Camera * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Camera * >::iterator

pos: std::vector< nvisii::Camera * >::iterator x: std::vector< nvisii::Camera * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Camera * >::iterator n: std::vector< nvisii::Camera * >::size_type x: std::vector< nvisii::Camera * >::value_type

iterator(self) → SwigPyIterator

pop(self) → camera

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Camera * >::value_type

rbegin(self) → std::vector< nvisii::Camera * >::reverse_iterator

rend(self) → std::vector< nvisii::Camera * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Camera * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Camera * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Camera * >::size_type x: std::vector< nvisii::Camera * >::value_type

size(self) → std::vector< nvisii::Camera * >::size_type

swap(self, v): v: std::vector< nvisii::Camera * > &

property thisown: The membership flag

class nvisii.EntityVector(*args)

Proxy of C++ std::vector< nvisii::Entity * > class.

append(self, x): x: std::vector< nvisii::Entity * >::value_type

assign(self, n, x): n: std::vector< nvisii::Entity * >::size_type x: std::vector< nvisii::Entity * >::value_type

back(self) → entity

begin(self) → std::vector< nvisii::Entity * >::iterator

capacity(self) → std::vector< nvisii::Entity * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Entity * >::iterator

erase(self, pos) → std::vector< nvisii::Entity * >::iterator

pos: std::vector< nvisii::Entity * >::iterator

erase(self, first, last) -> std::vector< nvisii::Entity * >::iterator

first: std::vector< nvisii::Entity * >::iterator last: std::vector< nvisii::Entity * >::iterator

front(self) → entity

get_allocator(self) → std::vector< nvisii::Entity * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Entity * >::iterator

pos: std::vector< nvisii::Entity * >::iterator x: std::vector< nvisii::Entity * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Entity * >::iterator n: std::vector< nvisii::Entity * >::size_type x: std::vector< nvisii::Entity * >::value_type

iterator(self) → SwigPyIterator

pop(self) → entity

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Entity * >::value_type

rbegin(self) → std::vector< nvisii::Entity * >::reverse_iterator

rend(self) → std::vector< nvisii::Entity * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Entity * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Entity * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Entity * >::size_type x: std::vector< nvisii::Entity * >::value_type

size(self) → std::vector< nvisii::Entity * >::size_type

swap(self, v): v: std::vector< nvisii::Entity * > &

property thisown: The membership flag

class nvisii.Float3Vector(*args)

Proxy of C++ std::vector< std::array< float,3 > > class.

append(self, x): x: std::vector< std::array< float,3 > >::value_type const &

assign(self, n, x): n: std::vector< std::array< float,3 > >::size_type x: std::vector< std::array< float,3 > >::value_type const &

back(self) → Float3

begin(self) → std::vector< std::array< float,3 > >::iterator

capacity(self) → std::vector< std::array< float,3 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::array< float,3 > >::iterator

erase(self, pos) → std::vector< std::array< float,3 > >::iterator

pos: std::vector< std::array< float,3 > >::iterator

erase(self, first, last) -> std::vector< std::array< float,3 > >::iterator

first: std::vector< std::array< float,3 > >::iterator last: std::vector< std::array< float,3 > >::iterator

front(self) → Float3

get_allocator(self) → std::vector< std::array< float,3 > >::allocator_type

insert(self, pos, x) → std::vector< std::array< float,3 > >::iterator

pos: std::vector< std::array< float,3 > >::iterator x: std::vector< std::array< float,3 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::array< float,3 > >::iterator n: std::vector< std::array< float,3 > >::size_type x: std::vector< std::array< float,3 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → Float3

pop_back(self)

push_back(self, x): x: std::vector< std::array< float,3 > >::value_type const &

rbegin(self) → std::vector< std::array< float,3 > >::reverse_iterator

rend(self) → std::vector< std::array< float,3 > >::reverse_iterator

reserve(self, n): n: std::vector< std::array< float,3 > >::size_type

resize(self, new_size)

new_size: std::vector< std::array< float,3 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::array< float,3 > >::size_type x: std::vector< std::array< float,3 > >::value_type const &

size(self) → std::vector< std::array< float,3 > >::size_type

swap(self, v): v: std::vector< std::array< float,3 > > &

property thisown: The membership flag

class nvisii.Float4Vector(*args)

Proxy of C++ std::vector< std::array< float,4 > > class.

append(self, x): x: std::vector< std::array< float,4 > >::value_type const &

assign(self, n, x): n: std::vector< std::array< float,4 > >::size_type x: std::vector< std::array< float,4 > >::value_type const &

back(self) → Float4

begin(self) → std::vector< std::array< float,4 > >::iterator

capacity(self) → std::vector< std::array< float,4 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::array< float,4 > >::iterator

erase(self, pos) → std::vector< std::array< float,4 > >::iterator

pos: std::vector< std::array< float,4 > >::iterator

erase(self, first, last) -> std::vector< std::array< float,4 > >::iterator

first: std::vector< std::array< float,4 > >::iterator last: std::vector< std::array< float,4 > >::iterator

front(self) → Float4

get_allocator(self) → std::vector< std::array< float,4 > >::allocator_type

insert(self, pos, x) → std::vector< std::array< float,4 > >::iterator

pos: std::vector< std::array< float,4 > >::iterator x: std::vector< std::array< float,4 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::array< float,4 > >::iterator n: std::vector< std::array< float,4 > >::size_type x: std::vector< std::array< float,4 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → Float4

pop_back(self)

push_back(self, x): x: std::vector< std::array< float,4 > >::value_type const &

rbegin(self) → std::vector< std::array< float,4 > >::reverse_iterator

rend(self) → std::vector< std::array< float,4 > >::reverse_iterator

reserve(self, n): n: std::vector< std::array< float,4 > >::size_type

resize(self, new_size)

new_size: std::vector< std::array< float,4 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::array< float,4 > >::size_type x: std::vector< std::array< float,4 > >::value_type const &

size(self) → std::vector< std::array< float,4 > >::size_type

swap(self, v): v: std::vector< std::array< float,4 > > &

property thisown: The membership flag

class nvisii.FloatVector(*args)

Proxy of C++ std::vector< float > class.

append(self, x): x: std::vector< float >::value_type const &

assign(self, n, x): n: std::vector< float >::size_type x: std::vector< float >::value_type const &

back(self) → std::vector< float >::value_type const &

begin(self) → std::vector< float >::iterator

capacity(self) → std::vector< float >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< float >::iterator

erase(self, pos) → std::vector< float >::iterator

pos: std::vector< float >::iterator

erase(self, first, last) -> std::vector< float >::iterator

first: std::vector< float >::iterator last: std::vector< float >::iterator

front(self) → std::vector< float >::value_type const &

get_allocator(self) → std::vector< float >::allocator_type

insert(self, pos, x) → std::vector< float >::iterator

pos: std::vector< float >::iterator x: std::vector< float >::value_type const &

insert(self, pos, n, x)

pos: std::vector< float >::iterator n: std::vector< float >::size_type x: std::vector< float >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → std::vector< float >::value_type

pop_back(self)

push_back(self, x): x: std::vector< float >::value_type const &

rbegin(self) → std::vector< float >::reverse_iterator

rend(self) → std::vector< float >::reverse_iterator

reserve(self, n): n: std::vector< float >::size_type

resize(self, new_size)

new_size: std::vector< float >::size_type

resize(self, new_size, x)

new_size: std::vector< float >::size_type x: std::vector< float >::value_type const &

size(self) → std::vector< float >::size_type

swap(self, v): v: std::vector< float > &

property thisown: The membership flag

class nvisii.IVec2Vector(*args)

Proxy of C++ std::vector< glm::ivec2 > class.

append(self, x): x: std::vector< glm::ivec2 >::value_type const &

assign(self, n, x): n: std::vector< glm::ivec2 >::size_type x: std::vector< glm::ivec2 >::value_type const &

back(self) → ivec2

begin(self) → std::vector< glm::ivec2 >::iterator

capacity(self) → std::vector< glm::ivec2 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::ivec2 >::iterator

erase(self, pos) → std::vector< glm::ivec2 >::iterator

pos: std::vector< glm::ivec2 >::iterator

erase(self, first, last) -> std::vector< glm::ivec2 >::iterator

first: std::vector< glm::ivec2 >::iterator last: std::vector< glm::ivec2 >::iterator

front(self) → ivec2

get_allocator(self) → std::vector< glm::ivec2 >::allocator_type

insert(self, pos, x) → std::vector< glm::ivec2 >::iterator

pos: std::vector< glm::ivec2 >::iterator x: std::vector< glm::ivec2 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::ivec2 >::iterator n: std::vector< glm::ivec2 >::size_type x: std::vector< glm::ivec2 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → ivec2

pop_back(self)

push_back(self, x): x: std::vector< glm::ivec2 >::value_type const &

rbegin(self) → std::vector< glm::ivec2 >::reverse_iterator

rend(self) → std::vector< glm::ivec2 >::reverse_iterator

reserve(self, n): n: std::vector< glm::ivec2 >::size_type

resize(self, new_size)

new_size: std::vector< glm::ivec2 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::ivec2 >::size_type x: std::vector< glm::ivec2 >::value_type const &

size(self) → std::vector< glm::ivec2 >::size_type

swap(self, v): v: std::vector< glm::ivec2 > &

property thisown: The membership flag

class nvisii.IVec2Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::ivec2 > > class.

append(self, x): x: std::vector< std::vector< glm::ivec2 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::ivec2 > >::size_type x: std::vector< std::vector< glm::ivec2 > >::value_type const &

back(self) → IVec2Vector

begin(self) → std::vector< std::vector< glm::ivec2 > >::iterator

capacity(self) → std::vector< std::vector< glm::ivec2 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::ivec2 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::ivec2 > >::iterator

pos: std::vector< std::vector< glm::ivec2 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::ivec2 > >::iterator

first: std::vector< std::vector< glm::ivec2 > >::iterator last: std::vector< std::vector< glm::ivec2 > >::iterator

front(self) → IVec2Vector

get_allocator(self) → std::vector< std::vector< glm::ivec2 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::ivec2 > >::iterator

pos: std::vector< std::vector< glm::ivec2 > >::iterator x: std::vector< std::vector< glm::ivec2 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::ivec2 > >::iterator n: std::vector< std::vector< glm::ivec2 > >::size_type x: std::vector< std::vector< glm::ivec2 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → IVec2Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::ivec2 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::ivec2 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::ivec2 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::ivec2 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::ivec2 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::ivec2 > >::size_type x: std::vector< std::vector< glm::ivec2 > >::value_type const &

size(self) → std::vector< std::vector< glm::ivec2 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::ivec2,std::allocator< glm::ivec2 > > > &

property thisown: The membership flag

class nvisii.IVec3Vector(*args)

Proxy of C++ std::vector< glm::ivec3 > class.

append(self, x): x: std::vector< glm::ivec3 >::value_type const &

assign(self, n, x): n: std::vector< glm::ivec3 >::size_type x: std::vector< glm::ivec3 >::value_type const &

back(self) → ivec3

begin(self) → std::vector< glm::ivec3 >::iterator

capacity(self) → std::vector< glm::ivec3 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::ivec3 >::iterator

erase(self, pos) → std::vector< glm::ivec3 >::iterator

pos: std::vector< glm::ivec3 >::iterator

erase(self, first, last) -> std::vector< glm::ivec3 >::iterator

first: std::vector< glm::ivec3 >::iterator last: std::vector< glm::ivec3 >::iterator

front(self) → ivec3

get_allocator(self) → std::vector< glm::ivec3 >::allocator_type

insert(self, pos, x) → std::vector< glm::ivec3 >::iterator

pos: std::vector< glm::ivec3 >::iterator x: std::vector< glm::ivec3 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::ivec3 >::iterator n: std::vector< glm::ivec3 >::size_type x: std::vector< glm::ivec3 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → ivec3

pop_back(self)

push_back(self, x): x: std::vector< glm::ivec3 >::value_type const &

rbegin(self) → std::vector< glm::ivec3 >::reverse_iterator

rend(self) → std::vector< glm::ivec3 >::reverse_iterator

reserve(self, n): n: std::vector< glm::ivec3 >::size_type

resize(self, new_size)

new_size: std::vector< glm::ivec3 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::ivec3 >::size_type x: std::vector< glm::ivec3 >::value_type const &

size(self) → std::vector< glm::ivec3 >::size_type

swap(self, v): v: std::vector< glm::ivec3 > &

property thisown: The membership flag

class nvisii.IVec3Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::ivec3 > > class.

append(self, x): x: std::vector< std::vector< glm::ivec3 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::ivec3 > >::size_type x: std::vector< std::vector< glm::ivec3 > >::value_type const &

back(self) → IVec3Vector

begin(self) → std::vector< std::vector< glm::ivec3 > >::iterator

capacity(self) → std::vector< std::vector< glm::ivec3 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::ivec3 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::ivec3 > >::iterator

pos: std::vector< std::vector< glm::ivec3 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::ivec3 > >::iterator

first: std::vector< std::vector< glm::ivec3 > >::iterator last: std::vector< std::vector< glm::ivec3 > >::iterator

front(self) → IVec3Vector

get_allocator(self) → std::vector< std::vector< glm::ivec3 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::ivec3 > >::iterator

pos: std::vector< std::vector< glm::ivec3 > >::iterator x: std::vector< std::vector< glm::ivec3 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::ivec3 > >::iterator n: std::vector< std::vector< glm::ivec3 > >::size_type x: std::vector< std::vector< glm::ivec3 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → IVec3Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::ivec3 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::ivec3 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::ivec3 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::ivec3 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::ivec3 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::ivec3 > >::size_type x: std::vector< std::vector< glm::ivec3 > >::value_type const &

size(self) → std::vector< std::vector< glm::ivec3 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::ivec3,std::allocator< glm::ivec3 > > > &

property thisown: The membership flag

class nvisii.IVec4Vector(*args)

Proxy of C++ std::vector< glm::ivec4 > class.

append(self, x): x: std::vector< glm::ivec4 >::value_type const &

assign(self, n, x): n: std::vector< glm::ivec4 >::size_type x: std::vector< glm::ivec4 >::value_type const &

back(self) → ivec4

begin(self) → std::vector< glm::ivec4 >::iterator

capacity(self) → std::vector< glm::ivec4 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::ivec4 >::iterator

erase(self, pos) → std::vector< glm::ivec4 >::iterator

pos: std::vector< glm::ivec4 >::iterator

erase(self, first, last) -> std::vector< glm::ivec4 >::iterator

first: std::vector< glm::ivec4 >::iterator last: std::vector< glm::ivec4 >::iterator

front(self) → ivec4

get_allocator(self) → std::vector< glm::ivec4 >::allocator_type

insert(self, pos, x) → std::vector< glm::ivec4 >::iterator

pos: std::vector< glm::ivec4 >::iterator x: std::vector< glm::ivec4 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::ivec4 >::iterator n: std::vector< glm::ivec4 >::size_type x: std::vector< glm::ivec4 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → ivec4

pop_back(self)

push_back(self, x): x: std::vector< glm::ivec4 >::value_type const &

rbegin(self) → std::vector< glm::ivec4 >::reverse_iterator

rend(self) → std::vector< glm::ivec4 >::reverse_iterator

reserve(self, n): n: std::vector< glm::ivec4 >::size_type

resize(self, new_size)

new_size: std::vector< glm::ivec4 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::ivec4 >::size_type x: std::vector< glm::ivec4 >::value_type const &

size(self) → std::vector< glm::ivec4 >::size_type

swap(self, v): v: std::vector< glm::ivec4 > &

property thisown: The membership flag

class nvisii.IVec4Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::ivec4 > > class.

append(self, x): x: std::vector< std::vector< glm::ivec4 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::ivec4 > >::size_type x: std::vector< std::vector< glm::ivec4 > >::value_type const &

back(self) → IVec4Vector

begin(self) → std::vector< std::vector< glm::ivec4 > >::iterator

capacity(self) → std::vector< std::vector< glm::ivec4 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::ivec4 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::ivec4 > >::iterator

pos: std::vector< std::vector< glm::ivec4 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::ivec4 > >::iterator

first: std::vector< std::vector< glm::ivec4 > >::iterator last: std::vector< std::vector< glm::ivec4 > >::iterator

front(self) → IVec4Vector

get_allocator(self) → std::vector< std::vector< glm::ivec4 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::ivec4 > >::iterator

pos: std::vector< std::vector< glm::ivec4 > >::iterator x: std::vector< std::vector< glm::ivec4 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::ivec4 > >::iterator n: std::vector< std::vector< glm::ivec4 > >::size_type x: std::vector< std::vector< glm::ivec4 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → IVec4Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::ivec4 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::ivec4 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::ivec4 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::ivec4 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::ivec4 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::ivec4 > >::size_type x: std::vector< std::vector< glm::ivec4 > >::value_type const &

size(self) → std::vector< std::vector< glm::ivec4 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::ivec4,std::allocator< glm::ivec4 > > > &

property thisown: The membership flag

class nvisii.LightVector(*args)

Proxy of C++ std::vector< nvisii::Light * > class.

append(self, x): x: std::vector< nvisii::Light * >::value_type

assign(self, n, x): n: std::vector< nvisii::Light * >::size_type x: std::vector< nvisii::Light * >::value_type

back(self) → light

begin(self) → std::vector< nvisii::Light * >::iterator

capacity(self) → std::vector< nvisii::Light * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Light * >::iterator

erase(self, pos) → std::vector< nvisii::Light * >::iterator

pos: std::vector< nvisii::Light * >::iterator

erase(self, first, last) -> std::vector< nvisii::Light * >::iterator

first: std::vector< nvisii::Light * >::iterator last: std::vector< nvisii::Light * >::iterator

front(self) → light

get_allocator(self) → std::vector< nvisii::Light * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Light * >::iterator

pos: std::vector< nvisii::Light * >::iterator x: std::vector< nvisii::Light * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Light * >::iterator n: std::vector< nvisii::Light * >::size_type x: std::vector< nvisii::Light * >::value_type

iterator(self) → SwigPyIterator

pop(self) → light

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Light * >::value_type

rbegin(self) → std::vector< nvisii::Light * >::reverse_iterator

rend(self) → std::vector< nvisii::Light * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Light * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Light * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Light * >::size_type x: std::vector< nvisii::Light * >::value_type

size(self) → std::vector< nvisii::Light * >::size_type

swap(self, v): v: std::vector< nvisii::Light * > &

property thisown: The membership flag

class nvisii.MaterialVector(*args)

Proxy of C++ std::vector< nvisii::Material * > class.

append(self, x): x: std::vector< nvisii::Material * >::value_type

assign(self, n, x): n: std::vector< nvisii::Material * >::size_type x: std::vector< nvisii::Material * >::value_type

back(self) → material

begin(self) → std::vector< nvisii::Material * >::iterator

capacity(self) → std::vector< nvisii::Material * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Material * >::iterator

erase(self, pos) → std::vector< nvisii::Material * >::iterator

pos: std::vector< nvisii::Material * >::iterator

erase(self, first, last) -> std::vector< nvisii::Material * >::iterator

first: std::vector< nvisii::Material * >::iterator last: std::vector< nvisii::Material * >::iterator

front(self) → material

get_allocator(self) → std::vector< nvisii::Material * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Material * >::iterator

pos: std::vector< nvisii::Material * >::iterator x: std::vector< nvisii::Material * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Material * >::iterator n: std::vector< nvisii::Material * >::size_type x: std::vector< nvisii::Material * >::value_type

iterator(self) → SwigPyIterator

pop(self) → material

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Material * >::value_type

rbegin(self) → std::vector< nvisii::Material * >::reverse_iterator

rend(self) → std::vector< nvisii::Material * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Material * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Material * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Material * >::size_type x: std::vector< nvisii::Material * >::value_type

size(self) → std::vector< nvisii::Material * >::size_type

swap(self, v): v: std::vector< nvisii::Material * > &

property thisown: The membership flag

class nvisii.MeshVector(*args)

Proxy of C++ std::vector< nvisii::Mesh * > class.

append(self, x): x: std::vector< nvisii::Mesh * >::value_type

assign(self, n, x): n: std::vector< nvisii::Mesh * >::size_type x: std::vector< nvisii::Mesh * >::value_type

back(self) → mesh

begin(self) → std::vector< nvisii::Mesh * >::iterator

capacity(self) → std::vector< nvisii::Mesh * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Mesh * >::iterator

erase(self, pos) → std::vector< nvisii::Mesh * >::iterator

pos: std::vector< nvisii::Mesh * >::iterator

erase(self, first, last) -> std::vector< nvisii::Mesh * >::iterator

first: std::vector< nvisii::Mesh * >::iterator last: std::vector< nvisii::Mesh * >::iterator

front(self) → mesh

get_allocator(self) → std::vector< nvisii::Mesh * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Mesh * >::iterator

pos: std::vector< nvisii::Mesh * >::iterator x: std::vector< nvisii::Mesh * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Mesh * >::iterator n: std::vector< nvisii::Mesh * >::size_type x: std::vector< nvisii::Mesh * >::value_type

iterator(self) → SwigPyIterator

pop(self) → mesh

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Mesh * >::value_type

rbegin(self) → std::vector< nvisii::Mesh * >::reverse_iterator

rend(self) → std::vector< nvisii::Mesh * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Mesh * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Mesh * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Mesh * >::size_type x: std::vector< nvisii::Mesh * >::value_type

size(self) → std::vector< nvisii::Mesh * >::size_type

swap(self, v): v: std::vector< nvisii::Mesh * > &

property thisown: The membership flag

class nvisii.StringVector(*args)

Proxy of C++ std::vector< std::string > class.

append(self, x): x: std::vector< std::string >::value_type const &

assign(self, n, x): n: std::vector< std::string >::size_type x: std::vector< std::string >::value_type const &

back(self) → std::vector< std::string >::value_type const &

begin(self) → std::vector< std::string >::iterator

capacity(self) → std::vector< std::string >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::string >::iterator

erase(self, pos) → std::vector< std::string >::iterator

pos: std::vector< std::string >::iterator

erase(self, first, last) -> std::vector< std::string >::iterator

first: std::vector< std::string >::iterator last: std::vector< std::string >::iterator

front(self) → std::vector< std::string >::value_type const &

get_allocator(self) → std::vector< std::string >::allocator_type

insert(self, pos, x) → std::vector< std::string >::iterator

pos: std::vector< std::string >::iterator x: std::vector< std::string >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::string >::iterator n: std::vector< std::string >::size_type x: std::vector< std::string >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → std::vector< std::string >::value_type

pop_back(self)

push_back(self, x): x: std::vector< std::string >::value_type const &

rbegin(self) → std::vector< std::string >::reverse_iterator

rend(self) → std::vector< std::string >::reverse_iterator

reserve(self, n): n: std::vector< std::string >::size_type

resize(self, new_size)

new_size: std::vector< std::string >::size_type

resize(self, new_size, x)

new_size: std::vector< std::string >::size_type x: std::vector< std::string >::value_type const &

size(self) → std::vector< std::string >::size_type

swap(self, v): v: std::vector< std::string > &

property thisown: The membership flag

class nvisii.SwigPyIterator(*args, **kwargs)

Proxy of C++ swig::SwigPyIterator class.

advance(self, n) → SwigPyIterator: n: ptrdiff_t

copy(self) → SwigPyIterator

decr(self, n=1) → SwigPyIterator: n: size_t

distance(self, x) → ptrdiff_t: x: swig::SwigPyIterator const &

equal(self, x) → bool: x: swig::SwigPyIterator const &

incr(self, n=1) → SwigPyIterator: n: size_t

next(self) → PyObject *

previous(self) → PyObject *

property thisown: The membership flag

value(self) → PyObject *

class nvisii.TextureVector(*args)

Proxy of C++ std::vector< nvisii::Texture * > class.

append(self, x): x: std::vector< nvisii::Texture * >::value_type

assign(self, n, x): n: std::vector< nvisii::Texture * >::size_type x: std::vector< nvisii::Texture * >::value_type

back(self) → texture

begin(self) → std::vector< nvisii::Texture * >::iterator

capacity(self) → std::vector< nvisii::Texture * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Texture * >::iterator

erase(self, pos) → std::vector< nvisii::Texture * >::iterator

pos: std::vector< nvisii::Texture * >::iterator

erase(self, first, last) -> std::vector< nvisii::Texture * >::iterator

first: std::vector< nvisii::Texture * >::iterator last: std::vector< nvisii::Texture * >::iterator

front(self) → texture

get_allocator(self) → std::vector< nvisii::Texture * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Texture * >::iterator

pos: std::vector< nvisii::Texture * >::iterator x: std::vector< nvisii::Texture * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Texture * >::iterator n: std::vector< nvisii::Texture * >::size_type x: std::vector< nvisii::Texture * >::value_type

iterator(self) → SwigPyIterator

pop(self) → texture

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Texture * >::value_type

rbegin(self) → std::vector< nvisii::Texture * >::reverse_iterator

rend(self) → std::vector< nvisii::Texture * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Texture * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Texture * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Texture * >::size_type x: std::vector< nvisii::Texture * >::value_type

size(self) → std::vector< nvisii::Texture * >::size_type

swap(self, v): v: std::vector< nvisii::Texture * > &

property thisown: The membership flag

class nvisii.TransformVector(*args)

Proxy of C++ std::vector< nvisii::Transform * > class.

append(self, x): x: std::vector< nvisii::Transform * >::value_type

assign(self, n, x): n: std::vector< nvisii::Transform * >::size_type x: std::vector< nvisii::Transform * >::value_type

back(self) → transform

begin(self) → std::vector< nvisii::Transform * >::iterator

capacity(self) → std::vector< nvisii::Transform * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Transform * >::iterator

erase(self, pos) → std::vector< nvisii::Transform * >::iterator

pos: std::vector< nvisii::Transform * >::iterator

erase(self, first, last) -> std::vector< nvisii::Transform * >::iterator

first: std::vector< nvisii::Transform * >::iterator last: std::vector< nvisii::Transform * >::iterator

front(self) → transform

get_allocator(self) → std::vector< nvisii::Transform * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Transform * >::iterator

pos: std::vector< nvisii::Transform * >::iterator x: std::vector< nvisii::Transform * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Transform * >::iterator n: std::vector< nvisii::Transform * >::size_type x: std::vector< nvisii::Transform * >::value_type

iterator(self) → SwigPyIterator

pop(self) → transform

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Transform * >::value_type

rbegin(self) → std::vector< nvisii::Transform * >::reverse_iterator

rend(self) → std::vector< nvisii::Transform * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Transform * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Transform * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Transform * >::size_type x: std::vector< nvisii::Transform * >::value_type

size(self) → std::vector< nvisii::Transform * >::size_type

swap(self, v): v: std::vector< nvisii::Transform * > &

property thisown: The membership flag

class nvisii.U16Vec2Vector(*args)

Proxy of C++ std::vector< glm::u16vec2 > class.

append(self, x): x: std::vector< glm::u16vec2 >::value_type const &

assign(self, n, x): n: std::vector< glm::u16vec2 >::size_type x: std::vector< glm::u16vec2 >::value_type const &

back(self) → u16vec2

begin(self) → std::vector< glm::u16vec2 >::iterator

capacity(self) → std::vector< glm::u16vec2 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::u16vec2 >::iterator

erase(self, pos) → std::vector< glm::u16vec2 >::iterator

pos: std::vector< glm::u16vec2 >::iterator

erase(self, first, last) -> std::vector< glm::u16vec2 >::iterator

first: std::vector< glm::u16vec2 >::iterator last: std::vector< glm::u16vec2 >::iterator

front(self) → u16vec2

get_allocator(self) → std::vector< glm::u16vec2 >::allocator_type

insert(self, pos, x) → std::vector< glm::u16vec2 >::iterator

pos: std::vector< glm::u16vec2 >::iterator x: std::vector< glm::u16vec2 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::u16vec2 >::iterator n: std::vector< glm::u16vec2 >::size_type x: std::vector< glm::u16vec2 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → u16vec2

pop_back(self)

push_back(self, x): x: std::vector< glm::u16vec2 >::value_type const &

rbegin(self) → std::vector< glm::u16vec2 >::reverse_iterator

rend(self) → std::vector< glm::u16vec2 >::reverse_iterator

reserve(self, n): n: std::vector< glm::u16vec2 >::size_type

resize(self, new_size)

new_size: std::vector< glm::u16vec2 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::u16vec2 >::size_type x: std::vector< glm::u16vec2 >::value_type const &

size(self) → std::vector< glm::u16vec2 >::size_type

swap(self, v): v: std::vector< glm::u16vec2 > &

property thisown: The membership flag

class nvisii.U16Vec2Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::u16vec2 > > class.

append(self, x): x: std::vector< std::vector< glm::u16vec2 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::u16vec2 > >::size_type x: std::vector< std::vector< glm::u16vec2 > >::value_type const &

back(self) → U16Vec2Vector

begin(self) → std::vector< std::vector< glm::u16vec2 > >::iterator

capacity(self) → std::vector< std::vector< glm::u16vec2 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::u16vec2 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::u16vec2 > >::iterator

pos: std::vector< std::vector< glm::u16vec2 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::u16vec2 > >::iterator

first: std::vector< std::vector< glm::u16vec2 > >::iterator last: std::vector< std::vector< glm::u16vec2 > >::iterator

front(self) → U16Vec2Vector

get_allocator(self) → std::vector< std::vector< glm::u16vec2 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::u16vec2 > >::iterator

pos: std::vector< std::vector< glm::u16vec2 > >::iterator x: std::vector< std::vector< glm::u16vec2 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::u16vec2 > >::iterator n: std::vector< std::vector< glm::u16vec2 > >::size_type x: std::vector< std::vector< glm::u16vec2 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → U16Vec2Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::u16vec2 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::u16vec2 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::u16vec2 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::u16vec2 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::u16vec2 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::u16vec2 > >::size_type x: std::vector< std::vector< glm::u16vec2 > >::value_type const &

size(self) → std::vector< std::vector< glm::u16vec2 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::u16vec2,std::allocator< glm::u16vec2 > > > &

property thisown: The membership flag

class nvisii.U16Vec3Vector(*args)

Proxy of C++ std::vector< glm::u16vec3 > class.

append(self, x): x: std::vector< glm::u16vec3 >::value_type const &

assign(self, n, x): n: std::vector< glm::u16vec3 >::size_type x: std::vector< glm::u16vec3 >::value_type const &

back(self) → u16vec3

begin(self) → std::vector< glm::u16vec3 >::iterator

capacity(self) → std::vector< glm::u16vec3 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::u16vec3 >::iterator

erase(self, pos) → std::vector< glm::u16vec3 >::iterator

pos: std::vector< glm::u16vec3 >::iterator

erase(self, first, last) -> std::vector< glm::u16vec3 >::iterator

first: std::vector< glm::u16vec3 >::iterator last: std::vector< glm::u16vec3 >::iterator

front(self) → u16vec3

get_allocator(self) → std::vector< glm::u16vec3 >::allocator_type

insert(self, pos, x) → std::vector< glm::u16vec3 >::iterator

pos: std::vector< glm::u16vec3 >::iterator x: std::vector< glm::u16vec3 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::u16vec3 >::iterator n: std::vector< glm::u16vec3 >::size_type x: std::vector< glm::u16vec3 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → u16vec3

pop_back(self)

push_back(self, x): x: std::vector< glm::u16vec3 >::value_type const &

rbegin(self) → std::vector< glm::u16vec3 >::reverse_iterator

rend(self) → std::vector< glm::u16vec3 >::reverse_iterator

reserve(self, n): n: std::vector< glm::u16vec3 >::size_type

resize(self, new_size)

new_size: std::vector< glm::u16vec3 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::u16vec3 >::size_type x: std::vector< glm::u16vec3 >::value_type const &

size(self) → std::vector< glm::u16vec3 >::size_type

swap(self, v): v: std::vector< glm::u16vec3 > &

property thisown: The membership flag

class nvisii.U16Vec3Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::u16vec3 > > class.

append(self, x): x: std::vector< std::vector< glm::u16vec3 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::u16vec3 > >::size_type x: std::vector< std::vector< glm::u16vec3 > >::value_type const &

back(self) → U16Vec3Vector

begin(self) → std::vector< std::vector< glm::u16vec3 > >::iterator

capacity(self) → std::vector< std::vector< glm::u16vec3 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::u16vec3 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::u16vec3 > >::iterator

pos: std::vector< std::vector< glm::u16vec3 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::u16vec3 > >::iterator

first: std::vector< std::vector< glm::u16vec3 > >::iterator last: std::vector< std::vector< glm::u16vec3 > >::iterator

front(self) → U16Vec3Vector

get_allocator(self) → std::vector< std::vector< glm::u16vec3 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::u16vec3 > >::iterator

pos: std::vector< std::vector< glm::u16vec3 > >::iterator x: std::vector< std::vector< glm::u16vec3 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::u16vec3 > >::iterator n: std::vector< std::vector< glm::u16vec3 > >::size_type x: std::vector< std::vector< glm::u16vec3 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → U16Vec3Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::u16vec3 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::u16vec3 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::u16vec3 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::u16vec3 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::u16vec3 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::u16vec3 > >::size_type x: std::vector< std::vector< glm::u16vec3 > >::value_type const &

size(self) → std::vector< std::vector< glm::u16vec3 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::u16vec3,std::allocator< glm::u16vec3 > > > &

property thisown: The membership flag

class nvisii.U16Vec4Vector(*args)

Proxy of C++ std::vector< glm::u16vec4 > class.

append(self, x): x: std::vector< glm::u16vec4 >::value_type const &

assign(self, n, x): n: std::vector< glm::u16vec4 >::size_type x: std::vector< glm::u16vec4 >::value_type const &

back(self) → u16vec4

begin(self) → std::vector< glm::u16vec4 >::iterator

capacity(self) → std::vector< glm::u16vec4 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::u16vec4 >::iterator

erase(self, pos) → std::vector< glm::u16vec4 >::iterator

pos: std::vector< glm::u16vec4 >::iterator

erase(self, first, last) -> std::vector< glm::u16vec4 >::iterator

first: std::vector< glm::u16vec4 >::iterator last: std::vector< glm::u16vec4 >::iterator

front(self) → u16vec4

get_allocator(self) → std::vector< glm::u16vec4 >::allocator_type

insert(self, pos, x) → std::vector< glm::u16vec4 >::iterator

pos: std::vector< glm::u16vec4 >::iterator x: std::vector< glm::u16vec4 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::u16vec4 >::iterator n: std::vector< glm::u16vec4 >::size_type x: std::vector< glm::u16vec4 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → u16vec4

pop_back(self)

push_back(self, x): x: std::vector< glm::u16vec4 >::value_type const &

rbegin(self) → std::vector< glm::u16vec4 >::reverse_iterator

rend(self) → std::vector< glm::u16vec4 >::reverse_iterator

reserve(self, n): n: std::vector< glm::u16vec4 >::size_type

resize(self, new_size)

new_size: std::vector< glm::u16vec4 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::u16vec4 >::size_type x: std::vector< glm::u16vec4 >::value_type const &

size(self) → std::vector< glm::u16vec4 >::size_type

swap(self, v): v: std::vector< glm::u16vec4 > &

property thisown: The membership flag

class nvisii.U16Vec4Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::u16vec4 > > class.

append(self, x): x: std::vector< std::vector< glm::u16vec4 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::u16vec4 > >::size_type x: std::vector< std::vector< glm::u16vec4 > >::value_type const &

back(self) → U16Vec4Vector

begin(self) → std::vector< std::vector< glm::u16vec4 > >::iterator

capacity(self) → std::vector< std::vector< glm::u16vec4 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::u16vec4 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::u16vec4 > >::iterator

pos: std::vector< std::vector< glm::u16vec4 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::u16vec4 > >::iterator

first: std::vector< std::vector< glm::u16vec4 > >::iterator last: std::vector< std::vector< glm::u16vec4 > >::iterator

front(self) → U16Vec4Vector

get_allocator(self) → std::vector< std::vector< glm::u16vec4 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::u16vec4 > >::iterator

pos: std::vector< std::vector< glm::u16vec4 > >::iterator x: std::vector< std::vector< glm::u16vec4 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::u16vec4 > >::iterator n: std::vector< std::vector< glm::u16vec4 > >::size_type x: std::vector< std::vector< glm::u16vec4 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → U16Vec4Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::u16vec4 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::u16vec4 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::u16vec4 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::u16vec4 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::u16vec4 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::u16vec4 > >::size_type x: std::vector< std::vector< glm::u16vec4 > >::value_type const &

size(self) → std::vector< std::vector< glm::u16vec4 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::u16vec4,std::allocator< glm::u16vec4 > > > &

property thisown: The membership flag

class nvisii.UINT32Vector(*args)

Proxy of C++ std::vector< uint32_t > class.

append(self, x): x: std::vector< unsigned int >::value_type const &

assign(self, n, x): n: std::vector< unsigned int >::size_type x: std::vector< unsigned int >::value_type const &

back(self) → std::vector< unsigned int >::value_type const &

begin(self) → std::vector< unsigned int >::iterator

capacity(self) → std::vector< unsigned int >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< unsigned int >::iterator

erase(self, pos) → std::vector< unsigned int >::iterator

pos: std::vector< unsigned int >::iterator

erase(self, first, last) -> std::vector< unsigned int >::iterator

first: std::vector< unsigned int >::iterator last: std::vector< unsigned int >::iterator

front(self) → std::vector< unsigned int >::value_type const &

get_allocator(self) → std::vector< unsigned int >::allocator_type

insert(self, pos, x) → std::vector< unsigned int >::iterator

pos: std::vector< unsigned int >::iterator x: std::vector< unsigned int >::value_type const &

insert(self, pos, n, x)

pos: std::vector< unsigned int >::iterator n: std::vector< unsigned int >::size_type x: std::vector< unsigned int >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → std::vector< unsigned int >::value_type

pop_back(self)

push_back(self, x): x: std::vector< unsigned int >::value_type const &

rbegin(self) → std::vector< unsigned int >::reverse_iterator

rend(self) → std::vector< unsigned int >::reverse_iterator

reserve(self, n): n: std::vector< unsigned int >::size_type

resize(self, new_size)

new_size: std::vector< unsigned int >::size_type

resize(self, new_size, x)

new_size: std::vector< unsigned int >::size_type x: std::vector< unsigned int >::value_type const &

size(self) → std::vector< unsigned int >::size_type

swap(self, v): v: std::vector< uint32_t > &

property thisown: The membership flag

class nvisii.Vec2Vector(*args)

Proxy of C++ std::vector< glm::vec2 > class.

append(self, x): x: std::vector< glm::vec2 >::value_type const &

assign(self, n, x): n: std::vector< glm::vec2 >::size_type x: std::vector< glm::vec2 >::value_type const &

back(self) → vec2

begin(self) → std::vector< glm::vec2 >::iterator

capacity(self) → std::vector< glm::vec2 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::vec2 >::iterator

erase(self, pos) → std::vector< glm::vec2 >::iterator

pos: std::vector< glm::vec2 >::iterator

erase(self, first, last) -> std::vector< glm::vec2 >::iterator

first: std::vector< glm::vec2 >::iterator last: std::vector< glm::vec2 >::iterator

front(self) → vec2

get_allocator(self) → std::vector< glm::vec2 >::allocator_type

insert(self, pos, x) → std::vector< glm::vec2 >::iterator

pos: std::vector< glm::vec2 >::iterator x: std::vector< glm::vec2 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::vec2 >::iterator n: std::vector< glm::vec2 >::size_type x: std::vector< glm::vec2 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → vec2

pop_back(self)

push_back(self, x): x: std::vector< glm::vec2 >::value_type const &

rbegin(self) → std::vector< glm::vec2 >::reverse_iterator

rend(self) → std::vector< glm::vec2 >::reverse_iterator

reserve(self, n): n: std::vector< glm::vec2 >::size_type

resize(self, new_size)

new_size: std::vector< glm::vec2 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::vec2 >::size_type x: std::vector< glm::vec2 >::value_type const &

size(self) → std::vector< glm::vec2 >::size_type

swap(self, v): v: std::vector< glm::vec2 > &

property thisown: The membership flag

class nvisii.Vec2Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::vec2 > > class.

append(self, x): x: std::vector< std::vector< glm::vec2 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::vec2 > >::size_type x: std::vector< std::vector< glm::vec2 > >::value_type const &

back(self) → Vec2Vector

begin(self) → std::vector< std::vector< glm::vec2 > >::iterator

capacity(self) → std::vector< std::vector< glm::vec2 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::vec2 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::vec2 > >::iterator

pos: std::vector< std::vector< glm::vec2 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::vec2 > >::iterator

first: std::vector< std::vector< glm::vec2 > >::iterator last: std::vector< std::vector< glm::vec2 > >::iterator

front(self) → Vec2Vector

get_allocator(self) → std::vector< std::vector< glm::vec2 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::vec2 > >::iterator

pos: std::vector< std::vector< glm::vec2 > >::iterator x: std::vector< std::vector< glm::vec2 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::vec2 > >::iterator n: std::vector< std::vector< glm::vec2 > >::size_type x: std::vector< std::vector< glm::vec2 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → Vec2Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::vec2 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::vec2 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::vec2 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::vec2 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::vec2 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::vec2 > >::size_type x: std::vector< std::vector< glm::vec2 > >::value_type const &

size(self) → std::vector< std::vector< glm::vec2 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::vec2,std::allocator< glm::vec2 > > > &

property thisown: The membership flag

class nvisii.Vec3Vector(*args)

Proxy of C++ std::vector< glm::vec3 > class.

append(self, x): x: std::vector< glm::vec3 >::value_type const &

assign(self, n, x): n: std::vector< glm::vec3 >::size_type x: std::vector< glm::vec3 >::value_type const &

back(self) → vec3

begin(self) → std::vector< glm::vec3 >::iterator

capacity(self) → std::vector< glm::vec3 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::vec3 >::iterator

erase(self, pos) → std::vector< glm::vec3 >::iterator

pos: std::vector< glm::vec3 >::iterator

erase(self, first, last) -> std::vector< glm::vec3 >::iterator

first: std::vector< glm::vec3 >::iterator last: std::vector< glm::vec3 >::iterator

front(self) → vec3

get_allocator(self) → std::vector< glm::vec3 >::allocator_type

insert(self, pos, x) → std::vector< glm::vec3 >::iterator

pos: std::vector< glm::vec3 >::iterator x: std::vector< glm::vec3 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::vec3 >::iterator n: std::vector< glm::vec3 >::size_type x: std::vector< glm::vec3 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → vec3

pop_back(self)

push_back(self, x): x: std::vector< glm::vec3 >::value_type const &

rbegin(self) → std::vector< glm::vec3 >::reverse_iterator

rend(self) → std::vector< glm::vec3 >::reverse_iterator

reserve(self, n): n: std::vector< glm::vec3 >::size_type

resize(self, new_size)

new_size: std::vector< glm::vec3 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::vec3 >::size_type x: std::vector< glm::vec3 >::value_type const &

size(self) → std::vector< glm::vec3 >::size_type

swap(self, v): v: std::vector< glm::vec3 > &

property thisown: The membership flag

class nvisii.Vec3Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::vec3 > > class.

append(self, x): x: std::vector< std::vector< glm::vec3 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::vec3 > >::size_type x: std::vector< std::vector< glm::vec3 > >::value_type const &

back(self) → Vec3Vector

begin(self) → std::vector< std::vector< glm::vec3 > >::iterator

capacity(self) → std::vector< std::vector< glm::vec3 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::vec3 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::vec3 > >::iterator

pos: std::vector< std::vector< glm::vec3 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::vec3 > >::iterator

first: std::vector< std::vector< glm::vec3 > >::iterator last: std::vector< std::vector< glm::vec3 > >::iterator

front(self) → Vec3Vector

get_allocator(self) → std::vector< std::vector< glm::vec3 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::vec3 > >::iterator

pos: std::vector< std::vector< glm::vec3 > >::iterator x: std::vector< std::vector< glm::vec3 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::vec3 > >::iterator n: std::vector< std::vector< glm::vec3 > >::size_type x: std::vector< std::vector< glm::vec3 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → Vec3Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::vec3 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::vec3 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::vec3 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::vec3 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::vec3 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::vec3 > >::size_type x: std::vector< std::vector< glm::vec3 > >::value_type const &

size(self) → std::vector< std::vector< glm::vec3 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::vec3,std::allocator< glm::vec3 > > > &

property thisown: The membership flag

class nvisii.Vec4Vector(*args)

Proxy of C++ std::vector< glm::vec4 > class.

append(self, x): x: std::vector< glm::vec4 >::value_type const &

assign(self, n, x): n: std::vector< glm::vec4 >::size_type x: std::vector< glm::vec4 >::value_type const &

back(self) → vec4

begin(self) → std::vector< glm::vec4 >::iterator

capacity(self) → std::vector< glm::vec4 >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< glm::vec4 >::iterator

erase(self, pos) → std::vector< glm::vec4 >::iterator

pos: std::vector< glm::vec4 >::iterator

erase(self, first, last) -> std::vector< glm::vec4 >::iterator

first: std::vector< glm::vec4 >::iterator last: std::vector< glm::vec4 >::iterator

front(self) → vec4

get_allocator(self) → std::vector< glm::vec4 >::allocator_type

insert(self, pos, x) → std::vector< glm::vec4 >::iterator

pos: std::vector< glm::vec4 >::iterator x: std::vector< glm::vec4 >::value_type const &

insert(self, pos, n, x)

pos: std::vector< glm::vec4 >::iterator n: std::vector< glm::vec4 >::size_type x: std::vector< glm::vec4 >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → vec4

pop_back(self)

push_back(self, x): x: std::vector< glm::vec4 >::value_type const &

rbegin(self) → std::vector< glm::vec4 >::reverse_iterator

rend(self) → std::vector< glm::vec4 >::reverse_iterator

reserve(self, n): n: std::vector< glm::vec4 >::size_type

resize(self, new_size)

new_size: std::vector< glm::vec4 >::size_type

resize(self, new_size, x)

new_size: std::vector< glm::vec4 >::size_type x: std::vector< glm::vec4 >::value_type const &

size(self) → std::vector< glm::vec4 >::size_type

swap(self, v): v: std::vector< glm::vec4 > &

property thisown: The membership flag

class nvisii.Vec4Vector2D(*args)

Proxy of C++ std::vector< std::vector< glm::vec4 > > class.

append(self, x): x: std::vector< std::vector< glm::vec4 > >::value_type const &

assign(self, n, x): n: std::vector< std::vector< glm::vec4 > >::size_type x: std::vector< std::vector< glm::vec4 > >::value_type const &

back(self) → Vec4Vector

begin(self) → std::vector< std::vector< glm::vec4 > >::iterator

capacity(self) → std::vector< std::vector< glm::vec4 > >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< std::vector< glm::vec4 > >::iterator

erase(self, pos) → std::vector< std::vector< glm::vec4 > >::iterator

pos: std::vector< std::vector< glm::vec4 > >::iterator

erase(self, first, last) -> std::vector< std::vector< glm::vec4 > >::iterator

first: std::vector< std::vector< glm::vec4 > >::iterator last: std::vector< std::vector< glm::vec4 > >::iterator

front(self) → Vec4Vector

get_allocator(self) → std::vector< std::vector< glm::vec4 > >::allocator_type

insert(self, pos, x) → std::vector< std::vector< glm::vec4 > >::iterator

pos: std::vector< std::vector< glm::vec4 > >::iterator x: std::vector< std::vector< glm::vec4 > >::value_type const &

insert(self, pos, n, x)

pos: std::vector< std::vector< glm::vec4 > >::iterator n: std::vector< std::vector< glm::vec4 > >::size_type x: std::vector< std::vector< glm::vec4 > >::value_type const &

iterator(self) → SwigPyIterator

pop(self) → Vec4Vector

pop_back(self)

push_back(self, x): x: std::vector< std::vector< glm::vec4 > >::value_type const &

rbegin(self) → std::vector< std::vector< glm::vec4 > >::reverse_iterator

rend(self) → std::vector< std::vector< glm::vec4 > >::reverse_iterator

reserve(self, n): n: std::vector< std::vector< glm::vec4 > >::size_type

resize(self, new_size)

new_size: std::vector< std::vector< glm::vec4 > >::size_type

resize(self, new_size, x)

new_size: std::vector< std::vector< glm::vec4 > >::size_type x: std::vector< std::vector< glm::vec4 > >::value_type const &

size(self) → std::vector< std::vector< glm::vec4 > >::size_type

swap(self, v): v: std::vector< std::vector< glm::vec4,std::allocator< glm::vec4 > > > &

property thisown: The membership flag

class nvisii.VolumeVector(*args)

Proxy of C++ std::vector< nvisii::Volume * > class.

append(self, x): x: std::vector< nvisii::Volume * >::value_type

assign(self, n, x): n: std::vector< nvisii::Volume * >::size_type x: std::vector< nvisii::Volume * >::value_type

back(self) → volume

begin(self) → std::vector< nvisii::Volume * >::iterator

capacity(self) → std::vector< nvisii::Volume * >::size_type

clear(self)

empty(self) → bool

end(self) → std::vector< nvisii::Volume * >::iterator

erase(self, pos) → std::vector< nvisii::Volume * >::iterator

pos: std::vector< nvisii::Volume * >::iterator

erase(self, first, last) -> std::vector< nvisii::Volume * >::iterator

first: std::vector< nvisii::Volume * >::iterator last: std::vector< nvisii::Volume * >::iterator

front(self) → volume

get_allocator(self) → std::vector< nvisii::Volume * >::allocator_type

insert(self, pos, x) → std::vector< nvisii::Volume * >::iterator

pos: std::vector< nvisii::Volume * >::iterator x: std::vector< nvisii::Volume * >::value_type

insert(self, pos, n, x)

pos: std::vector< nvisii::Volume * >::iterator n: std::vector< nvisii::Volume * >::size_type x: std::vector< nvisii::Volume * >::value_type

iterator(self) → SwigPyIterator

pop(self) → volume

pop_back(self)

push_back(self, x): x: std::vector< nvisii::Volume * >::value_type

rbegin(self) → std::vector< nvisii::Volume * >::reverse_iterator

rend(self) → std::vector< nvisii::Volume * >::reverse_iterator

reserve(self, n): n: std::vector< nvisii::Volume * >::size_type

resize(self, new_size)

new_size: std::vector< nvisii::Volume * >::size_type

resize(self, new_size, x)

new_size: std::vector< nvisii::Volume * >::size_type x: std::vector< nvisii::Volume * >::value_type

size(self) → std::vector< nvisii::Volume * >::size_type

swap(self, v): v: std::vector< nvisii::Volume * > &

property thisown: The membership flag

nvisii.abs(arg1) → float

arg1: float const &

abs(arg1) -> vec2

arg1: glm::vec2 const &

abs(arg1) -> vec3

arg1: glm::vec3 const &

abs(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.acos(arg1) → float

arg1: float const &

acos(arg1) -> vec2

arg1: glm::vec2 const &

acos(arg1) -> vec3

arg1: glm::vec3 const &

acos(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.acosh(arg1) → float

arg1: float const &

acosh(arg1) -> vec2

arg1: glm::vec2 const &

acosh(arg1) -> vec3

arg1: glm::vec3 const &

acosh(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.affineInverse(arg1) → mat3

arg1: glm::mat3 const &

affineInverse(arg1) -> mat4

arg1: glm::mat4 const &

nvisii.angle(x) → float

x: glm::quat const &

angle(arg1, arg2) -> float

arg1: glm::vec2 const & arg2: glm::vec2 const &

angle(arg1, arg2) -> float

arg1: glm::vec3 const & arg2: glm::vec3 const &

angle(arg1, arg2) -> float

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.angleAxis(angle, axis) → quat: angle: float const & axis: glm::vec3 const &

nvisii.asin(arg1) → float

arg1: float const &

asin(arg1) -> vec2

arg1: glm::vec2 const &

asin(arg1) -> vec3

arg1: glm::vec3 const &

asin(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.asinh(arg1) → float

arg1: float const &

asinh(arg1) -> vec2

arg1: glm::vec2 const &

asinh(arg1) -> vec3

arg1: glm::vec3 const &

asinh(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.atan(arg1, arg2) → float

arg1: float const & arg2: float const &

atan(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

atan(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

atan(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

atan(arg1) -> float

arg1: float const &

atan(arg1) -> vec2

arg1: glm::vec2 const &

atan(arg1) -> vec3

arg1: glm::vec3 const &

atan(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.atan2(arg1, arg2) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

atan2(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

atan2(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.atanh(arg1) → float

arg1: float const &

atanh(arg1) -> vec2

arg1: glm::vec2 const &

atanh(arg1) -> vec3

arg1: glm::vec3 const &

atanh(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.axis(x) → vec3: x: glm::quat const &

class nvisii.camera(*args, **kwargs)

The “Camera” component describes the perspective of an entity. It lens properties, like depth of field, focal length, field of view, and so on. It also describes the target render resolution. By connecting a camera component to an entity with a transform, that entity can be used to render the scene from a position in space.

static are_any_dirty(): Indicates whether or not any cameras are “out of date” and need to be updated through the “update components” function

static clear_all(): Clears any existing camera components.

static create(name, field_of_view=0.785398, aspect=1.0): Constructs a camera component. :type name: string :param name: A unique name for this camera. :type field_of_view: float, optional :param field_of_view: Specifies the field of view angle in the y direction. Expressed in radians. :type aspect: float, optional :param aspect: Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is a ratio of x (width) to y (height) :rtype: Camera :return: a reference to a camera component

static create_from_focal_length(name, focal_length, sensor_width, sensor_height)

Constructs a camera component from a focal length. The focal length controls the amount of zoom, i.e. the amount of the scene which is visible all at once. Longer focal lengths result in a smaller field of view (more zoom), while short focal lengths allow you to see more of the scene at once (larger FOV, less zoom)

Parameters

name (string) – A unique name for this camera.
focal_length (float) – Specifies the focal length of the camera lens (in millimeters).
sensor_width (float) – Specifies the width of the camera sensor (in millimeters).
sensor_height (float) – Specifies the height of the camera sensor (in millimeters).

Return type

Camera

Returns

a reference to a camera component

static create_from_fov(name, field_of_view, aspect)

Constructs a camera component from a field of view. The field of view controls the amount of zoom, i.e. the amount of the scene which is visible all at once. A smaller field of view results in a longer focal length (more zoom), while larger field of view allow you to see more of the scene at once (shorter focal length, less zoom)

Parameters

name (string) – A unique name for this camera.
field_of_view (float) – Specifies the field of view angle in the y direction. Expressed in radians.
aspect (float) – Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is a ratio of x (width) to y (height)

Return type

Camera

Returns

a reference to a camera component

static create_from_intrinsics(name, fx, fy, cx, cy, width, height, near=0.05, far=100.0)

Constructs a camera component from a set of intrinsic properties. These properties are common in computer-vision setups.

Parameters

name (string) – A unique name for this camera.
fx (float) – X-axis focal length in meters.
fy (float) – Y-axis focal length in meters.
cx (float) – X-axis optical center in pixels.
cy (float) – Y-axis optical center in pixels.
width (float) – Width of the current viewport, in pixels.
height (float) – Height of the current viewport, in pixels.
znear – The floating-point distance to the near clipping plane. If not specified, defaults to 0.05.
zfar – The floating-point distance to the far clipping plane. zfar must be greater than znear. If not specified, defaults to 100.0.

Return type

Camera

Returns

a reference to a camera component

static create_perspective_from_focal_length(name, focal_length, sensor_width, sensor_height): Deprecated in favor of create_from_focal_length

static create_perspective_from_fov(name, field_of_view, aspect): Deprecated in favor of either create or create_from_fov

static get(name)

Parameters: name (string) – The name of the camera to get
Return type: Camera
Returns: a Camera who’s name matches the given name

static get_count()

Return type: int
Returns: the number of allocated cameras.

static get_edit_mutex(): For internal use. Returns the mutex used to lock cameras for processing by the renderer.

static get_front()

Return type: Camera
Returns: a pointer to the list of Camera components.

static get_front_struct()

Return type: CameraStruct
Returns: a pointer to the table of CameraStructs

get_intrinsic_matrix(width, height): The intrinsic matrix is a 3x3 matrix that transforms 3D (non-homogeneous) cooordinates in camera space into 2D (homogeneous) image coordinates. These types of matrices are commonly used for computer vision applications, but are less common in computer graphics. :type width: float :param width: The width of the image (not tracked internally by the camera) :type height: float :param height: The height of the image (not tracked internally by the camera) :rtype: mat3 :return: An intrinsic matrix representation of the camera’s perspective.

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a camera name and whose value is the ID for that camera

get_projection()

Return type: mat4
Returns: the camera to projection matrix. This transform can be used to achieve perspective (eg a vanishing point), or for scaling an orthographic view.

get_struct(): Returns the simplified struct used to represent the current component

static initialize_factory(max_components): Allocates the tables used to store all Camera components

is_clean()

Return type: boolean
Returns: True if the camera has not been modified since the previous frame, and False otherwise

is_dirty()

Return type: boolean
Returns: True if the camera has been modified since the previous frame, and False otherwise

static is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all Camera components have been allocated, and False otherwise

is_initialized()

Return type: boolean
Returns: True the current camera is a valid, initialized camera, and False if the camera was cleared or removed.

mark_clean(): Tags the current component as being unmodified since the previous frame.

mark_dirty(): Tags the current component as being modified since the previous frame.

static remove(name)

Parameters: name (string) – The name of the camera to remove

set_aperture_diameter(diameter)

Real-world cameras transmit light through a lens that bends and focuses it onto the sensor. Because of this, objects that are a certain distance away are in focus, but objects in front and behind that are blurred.

Parameters: diameter (float) – Defines the amount of blurring by setting the diameter of the aperture (in millimeters).

set_focal_distance(distance)

Real-world cameras transmit light through a lens that bends and focuses it onto the sensor. Because of this, objects that are a certain distance away are in focus, but objects in front and behind that are blurred.

Parameters: distance (float) – The distance to the camera focal position. Note that this is different from focal length, and has no effect on the perspective of a camera.

NOTE: not to be confused with set_focal_length

set_focal_length(focal_length, sensor_width, sensor_height)

Tells the current camera component to use a projection matrix constructed from a focal length. The focal length controls the amount of zoom, i.e. the amount of the scene which is visible all at once. Longer focal lengths result in a smaller field of view (more zoom), while short focal lengths allow you to see more of the scene at once (larger FOV, less zoom)

Parameters

focal_length (float) – Specifies the focal length of the camera lens (in millimeters).
sensor_width (float) – Specifies the width of the camera sensor (in millimeters).
sensor_height (float) – Specifies the height of the camera sensor (in millimeters). NOTE: not to be confused with set_focal_distance

set_fov(field_of_view, aspect)

Tells the current camera component to use a projection matrix constructed from a field of view. The field of view controls the amount of zoom, i.e. the amount of the scene which is visible all at once. A smaller field of view results in a longer focal length (more zoom), while larger field of view allow you to see more of the scene at once (shorter focal length, less zoom)

Parameters

field_of_view (float) – Specifies the field of view angle in the y direction. Expressed in radians.
aspect (float) – Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is a ratio of x (width) to y (height)

set_intrinsics(fx, fy, cx, cy, width, height, near=0.05, far=100.0)

Constructs a projection matrix using custom intrinsics.

Parameters

fx (float) – X-axis focal length in meters.
fy (float) – Y-axis focal length in meters.
cx (float) – X-axis optical center in pixels.
cy (float) – Y-axis optical center in pixels.
width (float) – Width of the current viewport, in pixels.
height (float) – Height of the current viewport, in pixels.
znear – The floating-point distance to the near clipping plane. If not specified, defaults to 0.05.
zfar – The floating-point distance to the far clipping plane. zfar must be greater than znear. If not specified, defaults to 100.0.

set_projection(projection): Sets the projection matrix used to achieve a perspective (eg a vanishing point), or for scaling

an orthographic view

property thisown: The membership flag

to_string()

Return type: string
Returns: a string representation of the current component

static update_components(): Iterates through all components, updating any component struct fields and marking components as clean.

nvisii.camera_are_any_dirty(): Indicates whether or not any cameras are “out of date” and need to be updated through the “update components” function

nvisii.camera_clear_all(): Clears any existing camera components.

nvisii.camera_create(name, field_of_view=0.785398, aspect=1.0): Constructs a camera component. :type name: string :param name: A unique name for this camera. :type field_of_view: float, optional :param field_of_view: Specifies the field of view angle in the y direction. Expressed in radians. :type aspect: float, optional :param aspect: Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is a ratio of x (width) to y (height) :rtype: Camera :return: a reference to a camera component

nvisii.camera_create_from_focal_length(name, focal_length, sensor_width, sensor_height)

Constructs a camera component from a focal length. The focal length controls the amount of zoom, i.e. the amount of the scene which is visible all at once. Longer focal lengths result in a smaller field of view (more zoom), while short focal lengths allow you to see more of the scene at once (larger FOV, less zoom)

Parameters

name (string) – A unique name for this camera.
focal_length (float) – Specifies the focal length of the camera lens (in millimeters).
sensor_width (float) – Specifies the width of the camera sensor (in millimeters).
sensor_height (float) – Specifies the height of the camera sensor (in millimeters).

Return type

Camera

Returns

a reference to a camera component

nvisii.camera_create_from_fov(name, field_of_view, aspect)

Constructs a camera component from a field of view. The field of view controls the amount of zoom, i.e. the amount of the scene which is visible all at once. A smaller field of view results in a longer focal length (more zoom), while larger field of view allow you to see more of the scene at once (shorter focal length, less zoom)

Parameters

name (string) – A unique name for this camera.
field_of_view (float) – Specifies the field of view angle in the y direction. Expressed in radians.
aspect (float) – Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is a ratio of x (width) to y (height)

Return type

Camera

Returns

a reference to a camera component

nvisii.camera_create_from_intrinsics(name, fx, fy, cx, cy, width, height, near=0.05, far=100.0)

Constructs a camera component from a set of intrinsic properties. These properties are common in computer-vision setups.

Parameters

name (string) – A unique name for this camera.
fx (float) – X-axis focal length in meters.
fy (float) – Y-axis focal length in meters.
cx (float) – X-axis optical center in pixels.
cy (float) – Y-axis optical center in pixels.
width (float) – Width of the current viewport, in pixels.
height (float) – Height of the current viewport, in pixels.
znear – The floating-point distance to the near clipping plane. If not specified, defaults to 0.05.
zfar – The floating-point distance to the far clipping plane. zfar must be greater than znear. If not specified, defaults to 100.0.

Return type

Camera

Returns

a reference to a camera component

nvisii.camera_create_perspective_from_focal_length(name, focal_length, sensor_width, sensor_height): Deprecated in favor of create_from_focal_length

nvisii.camera_create_perspective_from_fov(name, field_of_view, aspect): Deprecated in favor of either create or create_from_fov

nvisii.camera_get(name)

Parameters: name (string) – The name of the camera to get
Return type: Camera
Returns: a Camera who’s name matches the given name

nvisii.camera_get_count()

Return type: int
Returns: the number of allocated cameras.

nvisii.camera_get_edit_mutex(): For internal use. Returns the mutex used to lock cameras for processing by the renderer.

nvisii.camera_get_front()

Return type: Camera
Returns: a pointer to the list of Camera components.

nvisii.camera_get_front_struct()

Return type: CameraStruct
Returns: a pointer to the table of CameraStructs

nvisii.camera_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a camera name and whose value is the ID for that camera

nvisii.camera_initialize_factory(max_components): Allocates the tables used to store all Camera components

nvisii.camera_is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all Camera components have been allocated, and False otherwise

nvisii.camera_remove(name)

Parameters: name (string) – The name of the camera to remove

nvisii.camera_update_components(): Iterates through all components, updating any component struct fields and marking components as clean.

nvisii.catmullRom(arg1, arg2, arg3, arg4, arg5) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const & arg4: glm::vec2 const & arg5: float const &

catmullRom(arg1, arg2, arg3, arg4, arg5) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const & arg4: glm::vec3 const & arg5: float const &

nvisii.ceil(arg1) → float

arg1: float const &

ceil(arg1) -> vec2

arg1: glm::vec2 const &

ceil(arg1) -> vec3

arg1: glm::vec3 const &

ceil(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.clamp(arg1, arg2, arg3) → float

arg1: float const & arg2: float const & arg3: float const &

clamp(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const &

clamp(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

clamp(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: glm::vec4 const &

clamp(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: float const & arg3: float const &

clamp(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: float const & arg3: float const &

clamp(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: float const & arg3: float const &

nvisii.clear_all(): Removes any allocated components but keeps nvisii initialized. Call this if you would like to clear the current scene.

nvisii.clear_dome_light_texture(): Disconnects the dome light texture, reverting back to any existing constant dome light color

nvisii.column(arg1, arg2) → vec3

arg1: glm::mat3 const & arg2: glm::length_t const &

column(arg1, arg2) -> vec4

arg1: glm::mat4 const & arg2: glm::length_t const &

column(arg1, arg2, arg3) -> mat3

arg1: glm::mat3 const & arg2: glm::length_t const & arg3: glm::vec3 const &

column(arg1, arg2, arg3) -> mat4

arg1: glm::mat4 const & arg2: glm::length_t const & arg3: glm::vec4 const &

nvisii.configure_denoiser(use_albedo_guide=True, use_normal_guide=True, use_kernel_prediction=True)

Controls what guides and modes are used to denoise the image. :type use_albedo_guide: boolean, optional :param use_albedo_guide: If True, uses albedo to guide the denoiser. Useful for scenes with

textures or large uniformly colored sections. Can cause issues when denoising motion blur.

Parameters

use_normal_guide (boolean, optional) – If True, uses surface normals to guide the denoiser. Useful for scenes where geometrically complex objects do not have distinct albedo (eg walls, uniformly colored objects, etc)
use_kernel_prediction (boolean, optional) – If True, uses the OptiX kernel prediction model for denoising, which avoids intensity shifts and false color prediction by instead predicting a normalized kernel.

nvisii.conjugate(q) → quat: q: glm::quat const &

nvisii.cos(arg1) → float

arg1: float const &

cos(arg1) -> vec2

arg1: glm::vec2 const &

cos(arg1) -> vec3

arg1: glm::vec3 const &

cos(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.cosh(arg1) → float

arg1: float const &

cosh(arg1) -> vec2

arg1: glm::vec2 const &

cosh(arg1) -> vec3

arg1: glm::vec3 const &

cosh(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.cross(arg1, arg2) → vec3: arg1: glm::vec3 const & arg2: glm::vec3 const &

nvisii.cubic(arg1, arg2, arg3, arg4, arg5) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const & arg4: glm::vec2 const & arg5: float const &

cubic(arg1, arg2, arg3, arg4, arg5) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const & arg4: glm::vec3 const & arg5: float const &

nvisii.degrees(arg1) → float

arg1: float const &

degrees(arg1) -> vec2

arg1: glm::vec2 const &

degrees(arg1) -> vec3

arg1: glm::vec3 const &

degrees(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.deinitialize(): Closes the interactive window, and shuts down any running backend systems. Call this function at the end of your script.

nvisii.determinant(arg1) → float

arg1: glm::mat3 const &

determinant(arg1) -> float

arg1: glm::mat4 const &

nvisii.disable_denoiser(): Disables the Optix denoiser.

nvisii.disable_dome_light_sampling(): If disabled, objects will not be lit by the dome light.

Instead, the dome light will only effect the background color.

nvisii.disable_updates(): If disabled, the interactive window image will only show scene changes on call to render, render_to_png, and render_data. Bulk component edits will be much faster when disabled, as all component edits can be done without the renderer locking them for upload to the GPU.

nvisii.distance(arg1, arg2) → float

arg1: glm::vec2 const & arg2: glm::vec2 const &

distance(arg1, arg2) -> float

arg1: glm::vec3 const & arg2: glm::vec3 const &

distance(arg1, arg2) -> float

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.distance2(arg1, arg2) → float

arg1: glm::vec2 const & arg2: glm::vec2 const &

distance2(arg1, arg2) -> float

arg1: glm::vec3 const & arg2: glm::vec3 const &

distance2(arg1, arg2) -> float

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.dot(x, y) → float

x: glm::quat const & y: glm::quat const &

dot(arg1, arg2) -> float

arg1: glm::vec2 const & arg2: glm::vec2 const &

dot(arg1, arg2) -> float

arg1: glm::vec3 const & arg2: glm::vec3 const &

dot(arg1, arg2) -> float

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.e() → float

nvisii.enable_denoiser(): Enables the Optix denoiser.

nvisii.enable_dome_light_sampling(): If enabled, objects will be lit by the dome light.

nvisii.enable_updates(): If enabled, the interactive window image will change asynchronously as scene components are altered. However, bulk component edits will slow down, as each component edit will individually cause the renderer to temporarily lock components while being uploaded to the GPU.

class nvisii.entity(*args, **kwargs)

An “Entity” is a component that is used to connect other component types together.

If you’d like to place an object in the scene, an Entity would be used to connect a Mesh component, a Transform component, and a Material component together.

Only one component of a given type can be connected to an entity at any given point in time.

Multiple entities can “share” the same component type. For example, a sphere mesh component can be referenced by many entities, with each entity having a unique material. This is essentially a form of “instancing”. Alternatively, many different entities can share the same Material component, such that any adjustments to that material component effect a collection of objects instead of just one.

static are_any_dirty()

Return type: boolean
Returns: True if any the entities has been modified since the previous frame, and False otherwise

static clear_all(): Clears any existing entity components. This function can be used to reset a scene.

clear_camera(): Disconnects any camera component from the current entity

clear_light(): Disconnects any light component from the current entity

clear_material(): Disconnects any material component from the current entity

clear_mesh(): Disconnects any mesh component from the current entity

clear_transform(): Disconnects any transform component from the current entity

clear_volume(): Disconnects any volume component from the current entity

compute_aabb(): For internal use.

static create(name, transform=None, material=None, mesh=None, light=None, camera=None, volume=None)

Constructs an Entity with the given name.

Parameters

transform (Transform, optional) – (optional) A transform component places the entity into the scene.
material (Material, optional) – (optional) A material component describes how an entity should look when rendered.
mesh (Mesh, optional) – (optional) A mesh component describes a surface to be rendered. Volume separating the inside and outside portion of the surface are implicitly represented using clockwise and counterclockwise triangles and corresponding surface normal. Note: Cannot be assigned if a “volume” component is also assigned.
light (Light, optional) – (optional) A light component indicates that any connected geometry should act like a light source.
camera (Camera, optional) – (optional) A camera component indicates that the current entity can be used to view into the scene.
volume (Volume, optional) – (optional) A volume component describes the volumetric particles to be rendered. Surfaces within the volume are implicitly defined using extinction. Note: Cannot be assigned if a “mesh” component is also assigned.

Return type

Entity

Returns

a reference to an Entity

static get(name)

Parameters: name (string) – The name of the entity to get
Return type: Entity
Returns: an Entity who’s name matches the given name

get_aabb_center()

Return type: vec3
Returns: the center of the aligned bounding box. Requires a transform and mesh component to be attached.

get_camera()

Return type: Camera
Returns: a reference to the connected camera component, or None/nullptr if no component is connected.

get_center()

Return type: vec3
Returns: the average of the vertices of the mesh in world space, which will lay roughly in the center. Requires a transform and mesh component to be attached.

static get_count()

Return type: int
Returns: the number of allocated entities

static get_dirty_entities()

Return type: std::set< nvisii::Entity * >
Returns: a list of entities that have been modified since the previous frame

get_id()

Return type: int
Returns: the unique integer ID for this component

get_light()

Return type: Light
Returns: a reference to the connected light component, or None/nullptr if no component is connected.

get_material()

Return type: Material
Returns: a reference to the connected material component, or None/nullptr if no component is connected.

get_max_aabb_corner()

Return type: vec3
Returns: the maximum axis aligned bounding box position. Requires a transform and mesh component to be attached.

get_mesh()

Return type: Mesh
Returns: a reference to the connected mesh component, or None/nullptr if no component is connected.

get_min_aabb_corner()

Return type: vec3
Returns: the minimum axis aligned bounding box position. Requires a transform and mesh component to be attached.

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is an entity name and whose value is the ID for that entity

static get_renderable_entities()

Return type: std::set< nvisii::Entity * >
Returns: a list of entities that are renderable (ie, can be seen) by the camera. (note, currently ignores visibility)

get_transform()

Return type: Transform
Returns: a reference to the connected transform component, or None/nullptr if no component is connected.

get_volume()

Return type: Volume
Returns: a reference to the connected volume component, or None/nullptr if no component is connected.

static initialize_factory(max_components): Allocates the tables used to store all Entity components

is_initialized()

Return type: boolean
Returns: True the current entity is a valid, initialized entity, and False if the entity was cleared or removed.

static remove(name)

Parameters: name (string) – The name of the Entity to remove

set_camera(camera): Connects a camera component to the current entity

set_light(light): Connects a light component to the current entity

set_material(material): Connects a material component to the current entity

set_mesh(mesh): Connects a mesh component to the current entity. Note: a mesh component cannot be attached if a volume component is currently attached.

set_transform(transform): Connects a transform component to the current entity

set_visibility(camera=True, diffuse=True, glossy=True, transmission=True, volume_scatter=True, shadow=True): Objects can be set to be invisible to particular ray types: :type camera: boolean, optional :param camera: Makes the object visible to camera rays (the first rays to be traced from the camera). :type diffuse: boolean, optional :param diffuse: Makes the object visible to diffuse rays (eg for diffuse GI) :type glossy: boolean, optional :param glossy: Makes the object visible to glossy rays (eg in reflections) :type transmission: boolean, optional :param transmission: Makes the object visible to transmission rays (eg from inside glass) :type volume_scatter: boolean, optional :param volume_scatter: Makes the object visible to volume scatter rays (eg from light simulation inside a volume) :type shadow: boolean, optional :param shadow: Enables the object to cast shadows.

set_volume(volume): Connects a volume component to the current entity. Note: a volume component cannot be attached if a mesh component is currently attached.

property thisown: The membership flag

to_string()

Return type: string
Returns: a string representation of the current component

update_renderables(): For internal use.

nvisii.entity_are_any_dirty()

Return type: boolean
Returns: True if any the entities has been modified since the previous frame, and False otherwise

nvisii.entity_clear_all(): Clears any existing entity components. This function can be used to reset a scene.

nvisii.entity_create(name, transform=None, material=None, mesh=None, light=None, camera=None, volume=None)

Constructs an Entity with the given name.

Parameters

transform (Transform, optional) – (optional) A transform component places the entity into the scene.
material (Material, optional) – (optional) A material component describes how an entity should look when rendered.
mesh (Mesh, optional) – (optional) A mesh component describes a surface to be rendered. Volume separating the inside and outside portion of the surface are implicitly represented using clockwise and counterclockwise triangles and corresponding surface normal. Note: Cannot be assigned if a “volume” component is also assigned.
light (Light, optional) – (optional) A light component indicates that any connected geometry should act like a light source.
camera (Camera, optional) – (optional) A camera component indicates that the current entity can be used to view into the scene.
volume (Volume, optional) – (optional) A volume component describes the volumetric particles to be rendered. Surfaces within the volume are implicitly defined using extinction. Note: Cannot be assigned if a “mesh” component is also assigned.

Return type

Entity

Returns

a reference to an Entity

nvisii.entity_get(name)

Parameters: name (string) – The name of the entity to get
Return type: Entity
Returns: an Entity who’s name matches the given name

nvisii.entity_get_count()

Return type: int
Returns: the number of allocated entities

nvisii.entity_get_dirty_entities()

Return type: std::set< nvisii::Entity * >
Returns: a list of entities that have been modified since the previous frame

nvisii.entity_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is an entity name and whose value is the ID for that entity

nvisii.entity_get_renderable_entities()

Return type: std::set< nvisii::Entity * >
Returns: a list of entities that are renderable (ie, can be seen) by the camera. (note, currently ignores visibility)

nvisii.entity_initialize_factory(max_components): Allocates the tables used to store all Entity components

nvisii.entity_remove(name)

Parameters: name (string) – The name of the Entity to remove

nvisii.epsilon() → float

nvisii.epsilonEqual(arg1, arg2, arg3) → bool

arg1: float const & arg2: float const & arg3: float const &

epsilonEqual(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: float const &

epsilonEqual(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: float const &

nvisii.epsilonNotEqual(arg1, arg2, arg3) → bool

arg1: float const & arg2: float const & arg3: float const &

epsilonNotEqual(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: float const &

epsilonNotEqual(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: float const &

nvisii.euler() → float

nvisii.eulerAngles(x) → vec3: x: glm::quat const &

nvisii.exp(arg1) → float

arg1: float const &

exp(arg1) -> vec2

arg1: glm::vec2 const &

exp(arg1) -> vec3

arg1: glm::vec3 const &

exp(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.exp2(arg1) → float

arg1: float const &

exp2(arg1) -> vec2

arg1: glm::vec2 const &

exp2(arg1) -> vec3

arg1: glm::vec3 const &

exp2(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.faceforward(arg1, arg2, arg3) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const &

faceforward(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

faceforward(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: glm::vec4 const &

nvisii.fastDistance(arg1, arg2) → float

arg1: glm::vec2 const & arg2: glm::vec2 const &

fastDistance(arg1, arg2) -> float

arg1: glm::vec3 const & arg2: glm::vec3 const &

fastDistance(arg1, arg2) -> float

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.fastInverseSqrt(arg1) → float

arg1: float const &

fastInverseSqrt(arg1) -> vec2

arg1: glm::vec2 const &

fastInverseSqrt(arg1) -> vec3

arg1: glm::vec3 const &

fastInverseSqrt(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.fastLength(arg1) → float

arg1: glm::vec2 const &

fastLength(arg1) -> float

arg1: glm::vec3 const &

fastLength(arg1) -> float

arg1: glm::vec4 const &

nvisii.fastNormalize(arg1) → vec2

arg1: glm::vec2 const &

fastNormalize(arg1) -> vec3

arg1: glm::vec3 const &

fastNormalize(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.fastSqrt(arg1) → vec2

arg1: glm::vec2 const &

fastSqrt(arg1) -> vec3

arg1: glm::vec3 const &

fastSqrt(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.floor(arg1) → float

arg1: float const &

floor(arg1) -> vec2

arg1: glm::vec2 const &

floor(arg1) -> vec3

arg1: glm::vec3 const &

floor(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.fract(arg1) → float

arg1: float const &

fract(arg1) -> vec2

arg1: glm::vec2 const &

fract(arg1) -> vec3

arg1: glm::vec3 const &

fract(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.frustum(arg1, arg2, arg3, arg4, arg5, arg6) → mat4: arg1: float const & arg2: float const & arg3: float const & arg4: float const & arg5: float const & arg6: float const &

nvisii.get_cursor_pos(): If in interactive mode, returns the position of the cursor relative to the window.

nvisii.get_scene_aabb_center()

Return type: vec3
Returns: the center of the aligned bounding box for the axis aligned bounding box containing all scene geometry

nvisii.get_scene_max_aabb_corner()

Return type: vec3
Returns: the maximum axis aligned bounding box position for the axis aligned bounding box containing all scene geometry

nvisii.get_scene_min_aabb_corner()

Return type: vec3
Returns: the minimum axis aligned bounding box position for the axis aligned bounding box containing all scene geometry

nvisii.get_window_size(): If in interactive mode, returns size of the window

nvisii.golden_ratio() → float

nvisii.half_pi() → float

nvisii.hermite(arg1, arg2, arg3, arg4, arg5) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const & arg4: glm::vec2 const & arg5: float const &

hermite(arg1, arg2, arg3, arg4, arg5) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const & arg4: glm::vec3 const & arg5: float const &

nvisii.import_scene(*args, **kwargs)

Imports a file containing scene data.

Supported file formats include: AMF 3DS AC ASE ASSBIN B3D BVH COLLADA DXF CSM HMP IRRMESH IRR LWO LWS M3D MD2 MD3 MD5 MDC MDL NFF NDO OFF OBJ OGRE OPENGEX PLY MS3D COB BLEND IFC XGL FBX Q3D Q3BSP RAW SIB SMD STL TERRAGEN 3D X X3D GLTF 3MF MMD

First, any materials described by the file are used to generate Material components. Next, any textures required by those materials will be loaded. After that, all shapes will be separated by material. For each separated shape, an entity is created to attach a transform, mesh, and material component together. These shapes are then translated so that the transform component is centered at the centroid of the shape. Finally, any specified position, scale, and/or rotation are applied to the generated transforms.

Parameters

filepath – The path for the file to load
position (vec3, optional) – A change in position to apply to all entities generated by this function
scale (vec3, optional) – A change in scale to apply to all entities generated by this function
rotation (quat, optional) – A change in rotation to apply to all entities generated by this function
args (std::vector< std::string,std::allocator< std::string > >, optional) – A list of optional arguments that can effect the importer. Possible options include: “verbose” - print out information related to loading the scene. Useful for debugging!

nvisii.infinitePerspective(arg1, arg2, arg3) → mat4: arg1: float const & arg2: float const & arg3: float const &

nvisii.initialize(headless=False, window_on_top=False, lazy_updates=False, verbose=False, max_entities=10000, max_cameras=10, max_transforms=10000, max_meshes=10000, max_materials=10000, max_lights=100, max_textures=1000, max_volumes=1000)

Initializes various backend systems required to render scene data.

Parameters

headless (boolean, optional) – If true, avoids using any OpenGL resources, to enable use on systems without displays.
window_on_top (boolean, optional) – Keeps the window opened during an interactive session on top of any other windows. (assuming headless is False)
lazy_updates (boolean, optional) – If True, nvisii will only upload components to the GPU on call to render/render_to_png/render_data for better scene editing performance. (assuming headless is False. Always on when headless is True)
verbose (boolean, optional) – If false, nvisii will avoid outputing any unneccessary text
max_entities (int, optional) – The max number of creatable Entity components.
max_cameras (int, optional) – The max number of creatable Camera components.
max_transforms (int, optional) – The max number of creatable Transform components.
max_meshes (int, optional) – The max number of creatable Mesh components.
max_materials (int, optional) – The max number of creatable Material components.
max_lights (int, optional) – The max number of creatable Light components.
max_textures (int, optional) – The max number of creatable Texture components.

nvisii.initialize_headless(verbose=False, max_entities=10000, max_cameras=10, max_transforms=10000, max_meshes=10000, max_materials=10000, max_lights=100, max_textures=1000, max_volumes=1000): Deprecated. Please use initialize(headless = True) instead.

nvisii.initialize_interactive(window_on_top=False, verbose=False, max_entities=10000, max_cameras=10, max_transforms=10000, max_meshes=10000, max_materials=10000, max_lights=100, max_textures=1000, max_volumes=1000): Deprecated. Please use initialize() instead.

nvisii.inverse(q) → quat

q: glm::quat const &

inverse(arg1) -> mat3

arg1: glm::mat3 const &

inverse(arg1) -> mat4

arg1: glm::mat4 const &

nvisii.inverseTranspose(arg1) → mat3

arg1: glm::mat3 const &

inverseTranspose(arg1) -> mat4

arg1: glm::mat4 const &

nvisii.inversesqrt(arg1) → float

arg1: float const &

inversesqrt(arg1) -> vec2

arg1: glm::vec2 const &

inversesqrt(arg1) -> vec3

arg1: glm::vec3 const &

inversesqrt(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.is_button_held(button): If in interactive mode, returns True if the specified button is held down. :param The: button to check. Not case sensitive. Possible options include:

SPACE, APOSTROPHE, COMMA, MINUS, PERIOD, SLASH, SEMICOLON, EQUAL, UP, DOWN, LEFT, RIGHT 0-9, A->Z, [, ], , `, ESCAPE, ENTER, TAB, BACKSPACE, INSERT, DELETE, PAGE_UP, PAGE_DOWN, HOME, CAPS_LOCK, SCROLL_LOCK, NUM_LOCK, PRINT_SCREEN, PAUSE, F1 -> F25, KP_0 -> KP_9, KP_DECIMAL, KP_DIVIDE, KP_MULTIPLY, KP_SUBTRACT, KP_ADD, KP_ENTER, KP_EQUAL, LEFT_SHIFT, LEFT_CONTROL, LEFT_ALT, LEFT_SUPER, RIGHT_SHIFT, RIGHT_CONTROL, RIGHT_ALT, RIGHT_SUPER, MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT

nvisii.is_button_pressed(button): If in interactive mode, returns True if the specified button is pressed but not held. :param The: button to check. Not case sensitive. Possible options include:

SPACE, APOSTROPHE, COMMA, MINUS, PERIOD, SLASH, SEMICOLON, EQUAL, UP, DOWN, LEFT, RIGHT 0-9, A->Z, [, ], , `, ESCAPE, ENTER, TAB, BACKSPACE, INSERT, DELETE, PAGE_UP, PAGE_DOWN, HOME, CAPS_LOCK, SCROLL_LOCK, NUM_LOCK, PRINT_SCREEN, PAUSE, F1 -> F25, KP_0 -> KP_9, KP_DECIMAL, KP_DIVIDE, KP_MULTIPLY, KP_SUBTRACT, KP_ADD, KP_ENTER, KP_EQUAL, LEFT_SHIFT, LEFT_CONTROL, LEFT_ALT, LEFT_SUPER, RIGHT_SHIFT, RIGHT_CONTROL, RIGHT_ALT, RIGHT_SUPER, MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT

nvisii.isfinite(arg1) → bool

arg1: float &

isfinite(arg1) -> vec2

arg1: glm::vec2 &

isfinite(arg1) -> vec3

arg1: glm::vec3 &

isfinite(arg1) -> vec4

arg1: glm::vec4 &

nvisii.isinf(arg1) → bool: arg1: float const &

nvisii.isnan(arg1) → bool: arg1: float const &

class nvisii.ivec2(*args)

Proxy of C++ glm::ivec2 class.

static length() → glm::length_t

property thisown: The membership flag

property x

property y

nvisii.ivec2_length() → glm::length_t

class nvisii.ivec3(*args)

Proxy of C++ glm::ivec3 class.

static length() → glm::length_t

property thisown: The membership flag

property x

property y

property z

nvisii.ivec3_length() → glm::length_t

class nvisii.ivec4(*args)

Proxy of C++ glm::ivec4 class.

static length() → glm::length_t

property thisown: The membership flag

property w

property x

property y

property z

nvisii.ivec4_length() → glm::length_t

nvisii.l1Norm(arg1, arg2) → float

arg1: glm::vec3 const & arg2: glm::vec3 const &

l1Norm(arg1) -> float

arg1: glm::vec3 const &

nvisii.l2Norm(arg1, arg2) → float

arg1: glm::vec3 const & arg2: glm::vec3 const &

l2Norm(arg1) -> float

arg1: glm::vec3 const &

nvisii.length(q) → float

q: glm::quat const &

length(arg1) -> float

arg1: glm::vec2 const &

length(arg1) -> float

arg1: glm::vec3 const &

length(arg1) -> float

arg1: glm::vec4 const &

nvisii.length2(arg1) → float

arg1: glm::vec2 const &

length2(arg1) -> float

arg1: glm::vec3 const &

length2(arg1) -> float

arg1: glm::vec4 const &

nvisii.lerp(x, y, a) → quat

x: glm::quat const & y: glm::quat const & a: float

lerp(arg1, arg2, arg3) -> float

arg1: float const & arg2: float const & arg3: float const &

lerp(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const &

lerp(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

lerp(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: glm::vec4 const &

lerp(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: float const &

lerp(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: float const &

lerp(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: float const &

class nvisii.light(*args, **kwargs)

A “Light” component illuminates objects in a scene. Light components must be added to an entity with a transform component to have a visible impact on the scene. Lights attached to entities with no mesh components act like point lights. Otherwise, lights attached to entities with meshes will act like mesh lights.

static are_any_dirty()

Return type: boolean
Returns: True if any the light has been modified since the previous frame, and False otherwise

static clear_all(): Clears any existing light components.

clear_color_texture(): Disconnects the color texture, reverting back to any existing constant

light color

static create(name)

Constructs a light with the given name.

Parameters: name (string) – A unique name for this light
Return type: Light
Returns: a reference to a light component

static create_from_rgb(name, color, intensity)

Constructs a light component which emits a given light color.

Parameters

name (string) – A unique name for this light.
color (vec3) – An RGB color to emit. Values should range between 0 and 1.
intensity (float) – How powerful the light source is in emitting light

static create_from_temperature(name, kelvin, intensity)

Constructs a light component which emits a plausible light color based on standard temperature measurement.

Parameters

name (string) – A unique name for this light
kelvin (float) – The temperature of the black body light. Typical values range from 1000K (very warm) to 12000K (very cold).
intensity (float) – How powerful the light source is in emitting light

Return type

Light

Returns

a reference to a light component

static get(name)

Parameters: name (string) – The name of the light to get
Return type: Light
Returns: a Light who’s name matches the given name

get_color()

Return type: vec3
Returns: the constant vec3 color used by this light. If a color texture is set, this function should not be used.

static get_count()

Return type: int
Returns: the number of allocated lights

static get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing

by the renderer.

get_exposure()

Return type: float
Returns: the constant exposure used by this light.

get_falloff()

Return type: float
Returns: the distance falloff exponent used by this light.

static get_front()

Return type: Light
Returns: a pointer to the table of light components

static get_front_struct()

Return type: LightStruct
Returns: a pointer to the table of LightStructs required for rendering

get_intensity()

Return type: float
Returns: the constant intensity used by this light.

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a light name and whose value is the ID for that light

get_struct(): Returns the simplified struct used to represent the current component

static initialize_factory(max_components): Allocates the tables used to store all light components

is_clean()

Return type: boolean
Returns: True if the light has not been modified since the previous frame, and False otherwise

is_dirty()

Return type: boolean
Returns: True if this lightmaterial has been modified since the previous frame, and False otherwise

static is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all light components have been allocated, and False otherwise

is_initialized()

Return type: boolean
Returns: True the current light is a valid, initialized light, and False if the light was cleared or removed.

mark_clean(): Tags the current component as being unmodified since the previous frame.

mark_dirty(): Tags the current component as being modified since the previous frame.

static remove(name)

Parameters: name (string) – The name of the Light to remove

set_color(color)

Sets the color which this light component will emit.

Parameters: The – RGB color emitted that this light should emit.

set_color_texture(texture)

Sets the color which this light component will emit. Texture is expected to be RGB. Overrides any existing constant light color.

Parameters: texture (Texture) – An RGB texture component whose values range between 0 and 1. Alpha channel is ignored.

set_exposure(exposure)

Modifies the intensity, or brightness, that this light component will emit it’s color by a power of 2. Increasing the exposure by 1 will double the energy emitted by the light. An exposure of 0 produces an unmodified intensity. An exposure of -1 cuts the intensity of the light in half. light_intensity = intensity * pow(2, exposureExposure)

Parameters: exposure (float) – How powerful the light source is in emitting light.

set_falloff(falloff)

Modifies the falloff exponent that this light component will use to reduce intensity due to distance. Physically realistic light transport uses an r^2 falloff, where the falloff exponent equals 2. Many video games instead use a linear falloff (falloff = 1). Distance falloff can be disabled in its entirety by setting falloff to 0.

Parameters: falloff (float) – The distance falloff exponent to use.

set_intensity(intensity)

Sets the intensity, or brightness, that this light component will emit it’s color.

Parameters: intensity (float) – How powerful the light source is in emitting light

set_temperature(kelvin)

Sets a realistic emission color via a temperature.

Parameters: kelvin (float) – The temperature of the black body light. Typical values range from 1000K (very warm) to 12000K (very cold).

property thisown: The membership flag

to_string()

Return type: string
Returns: a json string representation of the current component

static update_components(): Iterates through all light components, computing light metadata for

rendering purposes.

use_surface_area(use): Controls whether or not the surface area of the light should effect overall light intensity. :type use: boolean :param use: if True, allows the area of the light to affect intensity.

nvisii.light_are_any_dirty()

Return type: boolean
Returns: True if any the light has been modified since the previous frame, and False otherwise

nvisii.light_clear_all(): Clears any existing light components.

nvisii.light_create(name)

Constructs a light with the given name.

Parameters: name (string) – A unique name for this light
Return type: Light
Returns: a reference to a light component

nvisii.light_create_from_rgb(name, color, intensity)

Constructs a light component which emits a given light color.

Parameters

name (string) – A unique name for this light.
color (vec3) – An RGB color to emit. Values should range between 0 and 1.
intensity (float) – How powerful the light source is in emitting light

nvisii.light_create_from_temperature(name, kelvin, intensity)

Constructs a light component which emits a plausible light color based on standard temperature measurement.

Parameters

name (string) – A unique name for this light
kelvin (float) – The temperature of the black body light. Typical values range from 1000K (very warm) to 12000K (very cold).
intensity (float) – How powerful the light source is in emitting light

Return type

Light

Returns

a reference to a light component

nvisii.light_get(name)

Parameters: name (string) – The name of the light to get
Return type: Light
Returns: a Light who’s name matches the given name

nvisii.light_get_count()

Return type: int
Returns: the number of allocated lights

nvisii.light_get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing

by the renderer.

nvisii.light_get_front()

Return type: Light
Returns: a pointer to the table of light components

nvisii.light_get_front_struct()

Return type: LightStruct
Returns: a pointer to the table of LightStructs required for rendering

nvisii.light_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a light name and whose value is the ID for that light

nvisii.light_initialize_factory(max_components): Allocates the tables used to store all light components

nvisii.light_is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all light components have been allocated, and False otherwise

nvisii.light_remove(name)

Parameters: name (string) – The name of the Light to remove

nvisii.light_update_components(): Iterates through all light components, computing light metadata for

rendering purposes.

nvisii.ln_ln_two() → float

nvisii.ln_ten() → float

nvisii.ln_two() → float

nvisii.log(arg1) → float

arg1: float const &

log(arg1) -> vec2

arg1: glm::vec2 const &

log(arg1) -> vec3

arg1: glm::vec3 const &

log(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.log2(arg1) → float

arg1: float const &

log2(arg1) -> vec2

arg1: glm::vec2 const &

log2(arg1) -> vec3

arg1: glm::vec3 const &

log2(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.lookAt(arg1, arg2, arg3) → mat4: arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

nvisii.lxNorm(arg1, arg2, arg3) → float

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: unsigned int

lxNorm(arg1, arg2) -> float

arg1: glm::vec3 const & arg2: unsigned int

class nvisii.mat3(*args)

Proxy of C++ glm::mat3 class.

static length() → glm::length_t

property thisown: The membership flag

nvisii.mat3_cast(x) → mat3: x: glm::quat const &

nvisii.mat3_length() → glm::length_t

class nvisii.mat4(*args)

Proxy of C++ glm::mat4 class.

static length() → glm::length_t

property thisown: The membership flag

nvisii.mat4_cast(x) → mat4: x: glm::quat const &

nvisii.mat4_length() → glm::length_t

class nvisii.material(*args, **kwargs)

The “Material” component describes the surface properties of an entity. This material follows a physically based workflow, more specifically the Blender principled shader, and is very similar to the Disney material model.

static are_any_dirty()

Return type: boolean
Returns: True if any the material has been modified since the previous frame, and False otherwise

static clear_all(): Clears any existing material components.

clear_alpha_texture(): Disconnects the alpha texture, reverting back to any existing constant alpha

clear_anisotropic_rotation_texture(): Disconnects the anisotropic rotation texture, reverting back to any existing constant anisotropic rotation

clear_anisotropic_texture(): Disconnects the anisotropic texture, reverting back to any existing constant anisotropy

clear_base_color_texture(): Disconnects the base color texture, reverting back to any existing constant base color

clear_clearcoat_roughness_texture(): Disconnects the clearcoat roughness texture, reverting back to any existing constant clearcoat roughness

clear_clearcoat_texture(): Disconnects the clearcoat texture, reverting back to any existing constant clearcoat

clear_ior_texture(): Disconnects the ior texture, reverting back to any existing constant ior

clear_metallic_texture(): Disconnects the metallic texture, reverting back to any existing constant metallic

clear_normal_map_texture(): Disconnects the normal map texture

clear_roughness_texture(): Disconnects the roughness texture, reverting back to any existing constant roughness

clear_sheen_texture(): Disconnects the sheen texture, reverting back to any existing constant sheen

clear_sheen_tint_texture(): Disconnects the sheen tint texture, reverting back to any existing constant sheen tint

clear_specular_texture(): Disconnects the specular texture, reverting back to any existing constant specular

clear_specular_tint_texture(): Disconnects the specular tint texture, reverting back to any existing constant specular tint

clear_subsurface_color_texture(): Disconnects the subsurface color texture, reverting back to any existing constant subsurface color

clear_subsurface_radius_texture(): Disconnects the subsurface radius texture, reverting back to any existing constant subsurface radius

clear_subsurface_texture(): Disconnects the subsurface texture, reverting back to any existing constant subsurface

clear_transmission_roughness_texture(): Disconnects the TransmissionRoughness texture, reverting back to any existing constant TransmissionRoughness

clear_transmission_texture(): Disconnects the transmission texture, reverting back to any existing constant transmission

static create(*args, **kwargs)

Constructs a material with the given name.

Return type

Material

Returns

a reference to a material component

Parameters

name (string) – A unique name for this material.
base_color (vec3, optional) – The diffuse or metal surface color.
roughness (float, optional) – Microfacet roughness of the surface for diffuse and specular reflection.
metallic (float, optional) – Blends between a non-metallic and metallic material model.
specular (float, optional) – The amount of dielectric specular reflection.
specular_tint (float, optional) – Tints the facing specular reflection using the base color, while glancing reflection remains white.
transmission (float, optional) – Controls how much the surface looks like glass. Note, metallic takes precedence.
transmission_roughness (float, optional) – The roughness of the interior surface used for transmitted light.
ior (float, optional) – Index of refraction used for transmission events.
alpha (float, optional) – The transparency of the surface, independent of transmission.
subsurface_radius (vec3, optional) – Average distance that light scatters below the surface
subsurface_color (vec3, optional) – The subsurface scattering base color.
subsurface (float, optional) – Mix between diffuse and subsurface scattering.
anisotropic (float, optional) – The amount of anisotropy for specular reflection.
anisotropic_rotation (float, optional) – The angle of anisotropy.
sheen (float, optional) – Amount of soft velvet like reflection near edges, for simulating materials such as cloth.
sheen_tint (float, optional) – Mix between white and using base color for sheen reflection.
clearcoat (float, optional) – Extra white specular layer on top of others.
clearcoat_roughness (float, optional) – Microfacet surface roughness of clearcoat specular.

static get(name)

Gets a material by name

Return type: Material
Returns: a material who’s primary name key matches name
Parameters: name (string) – A unique name used to lookup this material.

get_alpha()

The transparency of the surface, independent of transmission.

Return type: float
Returns: the current surface transparency, with 1.0 being fully opaque and 0.0 being fully transparent.

get_anisotropic()

The amount of anisotropy for specular reflection.

Return type: float
Returns: The current amount of anisotropy for specular reflection.

get_anisotropic_rotation()

The angle of anisotropy.

Return type: float
Returns: the current the angle of anisotropy, between 0 and 1.

get_base_color()

The diffuse or metal surface color. Ignored if a base color texture is set.

Return type: vec3
Returns: the color intensity vector

get_clearcoat()

Extra white specular layer on top of others. This is useful for materials like car paint and the like.

Return type: float
Returns: the current clear coat influence

get_clearcoat_roughness()

Microfacet surface roughness of clearcoat specular.

Return type: float
Returns: the current clearcoat microfacet roughness value, between 0 and 1

static get_count()

Return type: int
Returns: the number of allocated materials

get_ior()

Index of refraction used for transmission events.

Return type: float
Returns: the current index of refraction.

get_metallic()

Blends between a non-metallic and metallic material model.

Return type: float
Returns: the current metallic value.

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a material name and whose value is the ID for that material

get_roughness()

Microfacet roughness of the surface for diffuse and specular reflection.

Return type: float
Returns: the current surface microfacet roughness value, between 0 and 1

get_sheen()

Amount of soft velvet like reflection near edges, for simulating materials such as cloth.

Return type: float
Returns: the current sheen amount, between 0 and 1

get_sheen_tint()

Mix between white and using base color for sheen reflection.

Return type: float
Returns: the current value used to mix between white and base color for sheen reflection.

get_specular()

The amount of dielectric specular reflection.

Return type: float
Returns: the current dielectric specular reflection value.

get_specular_tint()

Tints the facing specular reflection using the base color, while glancing reflection remains white.

Return type: float
Returns: the current specular tint value, between 0 and 1

get_subsurface()

Mix between diffuse and subsurface scattering.

Return type: float
Returns: the current subsurface radius multiplier.

get_subsurface_radius()

Average distance that light scatters below the surface. Higher radius gives a softer appearance, as light bleeds into shadows and through the object.

Return type: vec3
Returns: The subsurface scattering distance is specified separately for the RGB channels.

get_transmission()

Controls how much the surface looks like glass. Note, metallic takes precedence.

Return type: float
Returns: the current specular transmission of the surface.

get_transmission_roughness()

The roughness of the interior surface used for transmitted light.

Return type: float
Returns: the current roughness value used for transmitted light.

static initialize_factory(max_components): Allocates the tables used to store all material components

is_initialized()

Return type: boolean
Returns: True the current material is a valid, initialized material, and False if the material was cleared or removed.

static remove(name)

Parameters: name (string) – The name of the material to remove

set_alpha(a)

The transparency of the surface, independent of transmission.

Parameters: a (float) – Controls the transparency of the surface, with 1.0 being fully opaque.

set_alpha_texture(texture, channel=0)

The transparency of the surface, independent of transmission. Overrides any existing constant alpha

Parameters

texture (Texture) – A grayscale texture containing surface transparency values, with 1.0 being fully opaque and 0.0 being fully transparent.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_anisotropic(anisotropic)

The amount of anisotropy for specular reflection.

Parameters: anistropic – The amount of anisotropy for specular reflection. Higher values give elongated highlights along the tangent direction; negative values give highlights shaped perpendicular to the tangent direction.

set_anisotropic_rotation(anisotropicRotation): The angle of anisotropy. :param anisotropic_rotation: Rotates the angle of anisotropy, with 1.0 going full circle.

set_anisotropic_rotation_texture(texture, channel=0)

The angle of anisotropy. Overrides any existing constant anisotropic rotation

Parameters

texture (Texture) – A grayscale texture containing the angle of anisotropy, between 0 and 1.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_anisotropic_texture(texture, channel=0)

The amount of anisotropy for specular reflection. Overrides any existing constant anisotropy

Parameters

texture (Texture) – A grayscale texture containing amounts of anisotropy for specular reflection. G, B, and A channels are ignored.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_base_color(color)

The diffuse or metal surface color. Ignored if a base color texture is set.

Parameters: color (vec3) – a red, green, blue color intensity vector, usually between 0 and 1

set_base_color_texture(texture)

The diffuse or metal surface color. Texture is expected to be RGB. Overrides any existing constant base color.

Parameters: texture (Texture) – An RGB texture component whose values range between 0 and 1. Alpha channel is ignored.

set_clearcoat(clearcoat)

Extra white specular layer on top of others. This is useful for materials like car paint and the like.

Parameters: clearcoat (float) – controls the influence of clear coat, between 0 and 1

set_clearcoat_roughness(clearcoatRoughness)

Microfacet surface roughness of clearcoat specular.

Parameters: clearcoat_roughness – the roughness of the microfacet distribution influencing the clearcoat, between 0 and 1

set_clearcoat_roughness_texture(texture, channel=0)

Microfacet surface roughness of clearcoat specular. Overrides any existing constant clearcoat roughness

Parameters

texture (Texture) – the roughness of the microfacet distribution influencing the clearcoat, between 0 and 1
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_clearcoat_texture(texture, channel=0)

Extra white specular layer on top of others. Overrides any existing constant clearcoat

Parameters

texture (Texture) – A grayscale texture controlling the influence of clear coat, between 0 and 1.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_ior(ior)

Index of refraction used for transmission events.

Parameters: ior (float) – the index of refraction. A value of 1 results in no refraction. For reference, the IOR of water is roughly 1.33, and for glass is roughly 1.57.

set_ior_texture(texture, channel=0)

Index of refraction used for transmission events. Overrides any existing constant ior.

Parameters

texture (Texture) – the index of refraction. A value of 1 results in no refraction. For reference, the IOR of water is roughly 1.33, and for glass is roughly 1.57.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_metallic(metallic)

Blends between a non-metallic and metallic material model.

Parameters: metallic (float) – A value of 1.0 gives a fully specular reflection tinted with the base color, without diffuse reflection or transmission. At 0.0 the material consists of a diffuse or transmissive base layer, with a specular reflection layer on top.

set_metallic_texture(texture, channel=0)

Blends between a non-metallic and metallic material model. Overrides any existing constant metallic

Parameters

texture (Texture) – A grayscale texture, where texel values of 1 give a fully specular reflection tinted with the base color, without diffuse reflection or transmission. When texel values equal 0.0 the material consists of a diffuse or transmissive base layer, with a specular reflection layer on top.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_normal_map_texture(texture)

A normal map texture used to displace surface normals. Note that we expect R=X+, G=Y+, and B=Z+ (Matches Blender / OpenGL). Textures imported as “.dds” are an exception, and use R=X+, G=Y-, and B=Z+ (Matches DirectX style)

Parameters: texture (Texture) – A texture containing a surface normal displacement between 0 and 1. A channel is ignored.

set_roughness(roughness)

Microfacet roughness of the surface for diffuse and specular reflection.

Parameters: roughness (float) – Specifies the surface microfacet roughness value, between 0 and 1

set_roughness_texture(texture, channel=0)

Microfacet roughness of the surface for diffuse and specular reflection. Overrides any existing constant roughness

Parameters

texture (Texture) – A grayscale texture containing microfacet roughness values, between 0 and 1.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_sheen(sheen)

Amount of soft velvet like reflection near edges, for simulating materials such as cloth.

Parameters: sheen (float) – controls the amount of sheen, between 0 and 1

set_sheen_texture(texture, channel=0)

Amount of soft velvet like reflection near edges, for simulating materials such as cloth. Overrides any existing constant sheen

Parameters

texture (Texture) – A grayscale texture containing amounts of sheen, between 0 and 1.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_sheen_tint(sheenTint)

Mix between white and using base color for sheen reflection.

Parameters: sheen_tint – controls the mix between white and base color for sheen reflection.

set_sheen_tint_texture(texture, channel=0)

Mix between white and using base color for sheen reflection. Overrides any existing constant sheen tint

Parameters

texture (Texture) – A grayscale texture containing values used to mix between white and base color for sheen reflection.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_specular(specular)

The amount of dielectric specular reflection.

Parameters: specular (float) – Specifies facing (along normal) reflectivity in the most common 0 - 8% range. Since materials with reflectivity above 8% do exist, the field allows values above 1.

set_specular_texture(texture, channel=0)

The amount of dielectric specular reflection. Overrides any existing constant specular

Parameters

texture (Texture) – A grayscale texture containing dielectric specular reflection values.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_specular_tint(specularTint)

Tints the facing specular reflection using the base color, while glancing reflection remains white. Normal dielectrics have colorless reflection, so this parameter is not technically physically correct and is provided for faking the appearance of materials with complex surface structure.

Parameters: specular_tint – a value between 0 and 1, enabling/disabling specular tint

set_specular_tint_texture(texture, channel=0)

Tints the facing specular reflection using the base color, while glancing reflection remains white. Overrides any existing constant specular tint

Parameters

texture (Texture) – A grayscale texture containing specular tint values, between 0 and 1.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_subsurface(subsurface)

Mix between diffuse and subsurface scattering.

Parameters: subsurface (float) – Rather than being a simple mix between Diffuse and Subsurface Scattering, this value controls a multiplier for the Subsurface Radius.

set_subsurface_color(color)

The subsurface scattering base color.

Parameters: color (vec3) – the color intensity vector, usually between 0 and 1

set_subsurface_color_texture(texture)

The subsurface scattering base color. Overrides any existing constant subsurface color

Parameters: texture (Texture) – An RGB texture whose values range between 0 and 1. Alpha channel is ignored.

set_subsurface_radius(subsurfaceRadius)

Average distance that light scatters below the surface. Higher radius gives a softer appearance, as light bleeds into shadows and through the object. The scattering distance is specified separately for the RGB channels, to render materials such as skin where red light scatters deeper.

Parameters: subsurface_radius – control the subsurface radius. The X, Y and Z values of this vector are mapped to the R, G and B radius values, respectively.

set_subsurface_radius_texture(texture)

Average distance that light scatters below the surface. Higher radius gives a softer appearance, as light bleeds into shadows and through the object. Overrides any existing constant subsurface radius

Parameters: texture (Texture) – An RGB texture component controlling the subsurface radius in x, y, and z. Alpha channel is ignored.

set_subsurface_texture(texture, channel=0)

Mix between diffuse and subsurface scattering. Overrides any existing constant subsurface

Parameters

texture (Texture) – A grayscale texture component containing subsurface radius multipliers.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_transmission(transmission)

Controls how much the surface looks like glass. Note, metallic takes precedence.

Parameters: transmission (float) – Mixes between a fully opaque surface at zero to fully glass like transmissions at one.

set_transmission_roughness(transmissionRoughness)

The roughness of the interior surface used for transmitted light.

Parameters: transmission_roughness – Controls the roughness value used for transmitted light.

set_transmission_roughness_texture(texture, channel=0)

The roughness of the interior surface used for transmitted light. Overrides any existing constant transmission roughness

Parameters

texture (Texture) – Controls the roughness value used for transmitted light.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

set_transmission_texture(texture, channel=0)

Controls how much the surface looks like glass. Note, metallic takes precedence. Overrides any existing constant transmission.

Parameters

texture (Texture) – A grayscale texture containing the specular transmission of the surface.
channel (int, optional) – A value between 0 and 3 indicating the channel to use for this parameter.

property thisown: The membership flag

to_string(): Returns a json string representation of the current component

nvisii.material_are_any_dirty()

Return type: boolean
Returns: True if any the material has been modified since the previous frame, and False otherwise

nvisii.material_clear_all(): Clears any existing material components.

nvisii.material_create(*args, **kwargs)

Constructs a material with the given name.

Return type

Material

Returns

a reference to a material component

Parameters

name (string) – A unique name for this material.
base_color (vec3, optional) – The diffuse or metal surface color.
roughness (float, optional) – Microfacet roughness of the surface for diffuse and specular reflection.
metallic (float, optional) – Blends between a non-metallic and metallic material model.
specular (float, optional) – The amount of dielectric specular reflection.
specular_tint (float, optional) – Tints the facing specular reflection using the base color, while glancing reflection remains white.
transmission (float, optional) – Controls how much the surface looks like glass. Note, metallic takes precedence.
transmission_roughness (float, optional) – The roughness of the interior surface used for transmitted light.
ior (float, optional) – Index of refraction used for transmission events.
alpha (float, optional) – The transparency of the surface, independent of transmission.
subsurface_radius (vec3, optional) – Average distance that light scatters below the surface
subsurface_color (vec3, optional) – The subsurface scattering base color.
subsurface (float, optional) – Mix between diffuse and subsurface scattering.
anisotropic (float, optional) – The amount of anisotropy for specular reflection.
anisotropic_rotation (float, optional) – The angle of anisotropy.
sheen (float, optional) – Amount of soft velvet like reflection near edges, for simulating materials such as cloth.
sheen_tint (float, optional) – Mix between white and using base color for sheen reflection.
clearcoat (float, optional) – Extra white specular layer on top of others.
clearcoat_roughness (float, optional) – Microfacet surface roughness of clearcoat specular.

nvisii.material_get(name)

Gets a material by name

Return type: Material
Returns: a material who’s primary name key matches name
Parameters: name (string) – A unique name used to lookup this material.

nvisii.material_get_count()

Return type: int
Returns: the number of allocated materials

nvisii.material_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a material name and whose value is the ID for that material

nvisii.material_initialize_factory(max_components): Allocates the tables used to store all material components

nvisii.material_remove(name)

Parameters: name (string) – The name of the material to remove

nvisii.matrixCompMult(arg1, arg2) → mat3

arg1: glm::mat3 const & arg2: glm::mat3 const &

matrixCompMult(arg1, arg2) -> mat4

arg1: glm::mat4 const & arg2: glm::mat4 const &

nvisii.max(arg1, arg2) → float

arg1: float const & arg2: float const &

max(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

max(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

max(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

max(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: float const &

max(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: float const &

max(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: float const &

nvisii.mesh_are_any_dirty(): Indicates whether or not any meshes are “out of date” and need to be updated through the “update components” function

nvisii.mesh_clear_all(): Clears any existing Mesh components.

nvisii.mesh_create_box(*args, **kwargs)

Creates a rectangular box centered at the origin aligned along the x, y, and z axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
size (vec3, optional) – Half of the side length in x (0), y (1) and z (2) direction.
segments (ivec3, optional) – The number of segments in x (0), y (1) and z (2) directions. All should be >= 1. If any one is zero, faces in that direction are not genereted. If more than one is zero the mesh is empty.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_capped_cone(*args, **kwargs)

Creates a cone with a cap centered at the origin and pointing towards the positive z-axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Radius of the flat (negative z) end along the xy-plane.
size (float, optional) – Half of the length of the cylinder along the z-axis.
slices (int, optional) – Number of subdivisions around the z-axis.
segments (int, optional) – Number of subdivisions along the z-axis.
rings (int, optional) – Number of subdivisions of the cap.
start (float, optional) – Counterclockwise angle around the z-axis relative to the positive x-axis.
sweep (float, optional) – Counterclockwise angle around the z-axis.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_capped_cylinder(*args, **kwargs)

Creates a cylinder with a cap centered at the origin and aligned along the z-axis

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Radius of the cylinder along the xy-plane.
size (float, optional) – Half of the length cylinder along the z-axis.
slices (int, optional) – Number of subdivisions around the z-axis.
segments (int, optional) – Number of subdivisions along the z-axis.
rings (int, optional) – Number of subdivisions on the caps.
start (float, optional) – Counterclockwise angle around the z-axis relative to x-axis.
sweep (float, optional) – Counterclockwise angle around the z-axis.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_capped_tube(*args, **kwargs)

Creates a tube (a cylinder with thickness) with caps on both ends, centered at the origin and aligned along the z-axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – The outer radius of the cylinder on the xy-plane.
innerRadius (float, optional) – The inner radius of the cylinder on the xy-plane.
size (float, optional) – Half of the length of the cylinder along the z-axis.
slices (int, optional) – Number nubdivisions around the z-axis.
segments (int, optional) – Number of subdivisions along the z-axis.
rings (int, optional) – Number radial subdivisions in the cap.
start (float, optional) – Counterclockwise angle around the z-axis relative to the x-axis.
sweep (float, optional) – Counterclockwise angle around the z-axis.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_capsule(*args, **kwargs)

Creates a capsule (a cylinder with spherical caps) centered at the origin and aligned along the z-axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Radius of the capsule on the xy-plane.
size (float, optional) – Half of the length between centers of the caps along the z-axis.
slices (int, optional) – Number of subdivisions around the z-axis in the caps.
segments (int, optional) – Number radial subdivisions in the cylinder.
rings (int, optional) – Number of radial subdivisions in the caps.
start (float, optional) – Counterclockwise angle relative to the x-axis.
sweep (float, optional) – Counterclockwise angle.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_cone(*args, **kwargs)

Creates a cone centered at the origin, and whose tip points towards the z-axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Radius of the negative z end on the xy-plane.
size (float, optional) – Half of the length of the cylinder along the z-axis.
slices (int, optional) – Number of subdivisions around the z-axis.
segments (int, optional) – Number subdivisions along the z-axis.
start (float, optional) – Counterclockwise angle around the z-axis relative to the x-axis.
sweep (float, optional) – Counterclockwise angle around the z-axis.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_convex_polygon(name, vertices, segments=1, rings=1)

Creates a convex polygon from a set of corner vertices.

Parameters

name (string) – The name (used as a primary key) for this mesh component
vertices (std::vector< glm::vec2,std::allocator< glm::vec2 > >) – The corner coplanar vertex coordinates. Should form a convex polygon.
segments (int, optional) – The number of segments per side. Should be >= 1. If zero an empty mesh is generated.
rings (int, optional) – The number of radial segments. Should be >= 1. = yields an empty mesh.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_convex_polygon_from_circle(name, radius=1.0, sides=5, segments=4, rings=4)

Creates a convex polygonal disk with an arbitrary number of corners.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – The radius the enclosing circle.
sides (int, optional) – The number of sides. Should be >= 3. If <3 an empty mesh is generated.
segments (int, optional) – The number of segments per side. Should be >= 1. If zero an empty mesh is generated.
rings (int, optional) – The number of radial segments. Should be >= 1. = yields an empty mesh.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_cylinder(*args, **kwargs)

Creates an uncapped cylinder centered at the origin and aligned along the z-axis

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Radius of the cylinder along the xy-plane.
size (float, optional) – Half of the length of the cylinder along the z-axis.
slices (int, optional) – Subdivisions around the z-axis.
segments (int, optional) – Subdivisions along the z-axis.
start (float, optional) – Counterclockwise angle around the z-axis relative to the x-axis.
sweep (float, optional) – Counterclockwise angle around the z-axis.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_disk(*args, **kwargs)

Creates a circular disk centered at the origin and along the xy-plane

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Outer radius of the disk on the xy-plane.
innerRadius (float, optional) – radius of the inner circle on the xy-plane.
slices (int, optional) – Number of subdivisions around the z-axis.
rings (int, optional) – Number of subdivisions along the radius.
start (float, optional) – Counterclockwise angle relative to the x-axis
sweep (float, optional) – Counterclockwise angle.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_dodecahedron(name, radius=1.0, segments=1, rings=1)

Creates a regular dodecahedron centered at the origin and with a given radius.

Parameters

name (string) – The name (used as a primary key) for this mesh component Each face is optionally subdivided along the edges and/or radius.
radius (float, optional) – The radius of the enclosing sphere.
segments (int, optional) – The number segments along each edge. Should be >= 1. If <1 empty mesh is generated.
rings (int, optional) – The number of radial segments on each face. Should be >= 1. If <1 an empty mesh is generated.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_from_data(*args, **kwargs)

Creates a mesh component from a set of positions, optional normals, optional colors, optional texture coordinates, and optional indices. If anything other than positions is supplied (eg normals), that list must be the same length as the point list. If indicies are supplied, indices must be a multiple of 3 (triangles). Otherwise, all other supplied per vertex data must be a multiple of 3 in length.

Parameters

name (string) – The name (used as a primary key) for this mesh component
positions (std::vector< float,std::allocator< float > >) – A list of vertex positions. If indices aren’t supplied, this must be a multiple of 3.
position_dimensions (int, optional) – The number of floats per position. Valid numbers are 3 or 4.
normals (std::vector< float,std::allocator< float > >, optional) – A list of vertex normals. If indices aren’t supplied, this must be a multiple of 3.
normal_dimensions (int, optional) – The number of floats per normal. Valid numbers are 3 or 4.
tangents (std::vector< float,std::allocator< float > >, optional) – A list of vertex tangents. If indices aren’t supplied, this must be a multiple of 3.
tangent_dimensions (int, optional) – The number of floats per tangent. Valid numbers are 3 or 4.
colors (std::vector< float,std::allocator< float > >, optional) – A list of per-vertex colors. If indices aren’t supplied, this must be a multiple of 3.
color_dimensions (int, optional) – The number of floats per color. Valid numbers are 3 or 4.
texcoords (std::vector< float,std::allocator< float > >, optional) – A list of 2D per-vertex texture coordinates. If indices aren’t supplied, this must be a multiple of 3.
texcoord_dimensions (int, optional) – The number of floats per texcoord. Valid numbers are 2. (3 might be supported later for 3D textures…)
indices (std::vector< uint32_t,std::allocator< uint32_t > >, optional) – A list of integer indices connecting vertex positions in a counterclockwise ordering to form triangles. If supplied, indices must be a multiple of 3.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_from_file(name, path)

Creates a mesh component from a file (ignoring any associated materials)

Supported file formats include: AMF 3DS AC ASE ASSBIN B3D BVH COLLADA DXF CSM HMP IRRMESH IRR LWO LWS M3D MD2 MD3 MD5 MDC MDL NFF NDO OFF OBJ OGRE OPENGEX PLY MS3D COB BLEND IFC XGL FBX Q3D Q3BSP RAW SIB SMD STL TERRAGEN 3D X X3D GLTF 3MF MMD

Parameters

name (string) – The name (used as a primary key) for this mesh component
path (string) – A path to the file.

nvisii.mesh_create_from_obj(name, path): Deprecated. Please use create_from_file instead.

nvisii.mesh_create_icosahedron(name, radius=1.0, segments=1)

Creates a regular icosahedron centered at the origin and with a given radius.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – The radius of the enclosing sphere.
segments (int, optional) – The number segments along each edge. Must be >= 1.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_icosphere(name, radius=1.0, segments=4)

Creates an icosphere, otherwise known as a spherical subdivided icosahedron.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – The radius of the containing sphere.
segments (int, optional) – The number of segments per icosahedron edge. Must be >= 1.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_line(name, start, stop, radius=1.0, segments=16)

Creates a line from a circle extruded linearly between the specified start and stop positions.

type name

string

param name

The name (used as a primary key) for this mesh component

type start

vec3

param start

The start position of the linear path.

type start

vec3

param start

The stop position of the linear path.

type radius

float, optional

param radius

The radius of the extruded circle

type segments

int, optional

param segments

Number of subdivisions around the circle.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_plane(*args, **kwargs)

Creates a plane (a regular grid) on the xy-plane whose normal points towards the z-axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
size (vec2, optional) – Half of the side length in x (0) and y (1) direction.
segments (ivec2, optional) – Number of subdivisions in the x (0) and y (1) direction.
flip_z (boolean, optional) – Flips the plane such that the face is pointed down negative Z instead of positive Z.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_rectangle_tube_from_polyline(*args, **kwargs)

Creates a tube from a rounded rectangle extruded linearly along the specified path.

type name

string

param name

The name (used as a primary key) for this mesh component

type path

std::vector< glm::vec3,std::allocator< glm::vec3 > >

param path

A set of vertices describing a linear path.

type size

vec2, optional

param size

Half of the length of an edge

type segments

ivec2, optional

param segments

Number of subdivisions along each edge

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_rounded_box(*args, **kwargs)

Creates a rectangular box with rounded edges, centered at the origin and aligned along the x, y, and z axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
radius (float, optional) – Radius of the rounded edges.
size (vec3, optional) – Half of the side length in x (0), y (1) and z (2) direction.
slices (int, optional) – Number subdivions around in the rounded edges.
segments (ivec3, optional) – Number of subdivisions in x (0), y (1) and z (2) direction for the flat faces.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_create_rounded_rectangle_tube_from_polyline(*args, **kwargs)

Creates a tube from a rounded rectangle extruded linearly along the specified path.

type name

string

param name

The name (used as a primary key) for this mesh component

type path

std::vector< glm::vec3,std::allocator< glm::vec3 > >

param path

A set of vertices describing a linear path.

type radius

float, optional

param radius

The radius of the rounded corners

type size

vec2, optional

param size

Half of the length of an edge

type slices

int, optional

param slices

Number of subdivisions in each rounded corner

type segments

ivec2, optional

param segments

Number of subdivisions along each edge

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_sphere(*args, **kwargs)

Creates a sphere of the given radius, centered around the origin, subdivided around the z-axis in slices and along the z-axis in segments.

type name

string

param name

The name (used as a primary key) for this mesh component

type radius

float, optional

param radius

The radius of the sphere

type slices

int, optional

param slices

Subdivisions around the z-axis (longitudes).

type segments

int, optional

param segments

Subdivisions along the z-axis (latitudes).

type sliceStart

float, optional

param sliceStart

Counterclockwise angle around the z-axis relative to x-axis.

type sliceSweep

float, optional

param sliceSweep

Counterclockwise angle.

type segmentStart

float, optional

param segmentStart

Counterclockwise angle relative to the z-axis.

type segmentSweep

float, optional

param segmentSweep

Counterclockwise angle.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_spherical_cone(*args, **kwargs)

Creates a cone with a spherical cap, centered at the origin and whose tip points towards the z-axis.

Each point on the cap has equal distance from the tip.

type name: string
param name: The name (used as a primary key) for this mesh component
type radius: float, optional
param radius: Radius of the negative z end on the xy-plane.
type size: float, optional
param size: Half of the distance between cap and tip along the z-axis.
type slices: int, optional
param slices: Number of subdivisions around the z-axis.
type segments: int, optional
param segments: Number subdivisions along the z-axis.
type rings: int, optional
param rings: Number subdivisions in the cap.
type start: float, optional
param start: Counterclockwise angle around the z-axis relative to the positive x-axis.
type sweep: float, optional
param sweep: Counterclockwise angle around the z-axis.
rtype: Mesh
return: a reference to the mesh component

nvisii.mesh_create_spherical_triangle_from_sphere(name, radius=1.0, segments=4)

Creates a triangular region on the surface of a sphere.

type name

string

param name

The name (used as a primary key) for this mesh component

type radius

float, optional

param radius

Radius of the containing sphere.

type segments

int, optional

param segments

Number of subdivisions along each edge.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_spherical_triangle_from_triangle(name, v0, v1, v2, segments=4)

Creates a triangular region on the surface of a sphere.

type name

string

param name

The name (used as a primary key) for this mesh component

type v0

vec3

param v0

First of the three counter-clockwise triangle vertices

type v1

vec3

param v1

Second of the three counter-clockwise triangle vertices

type v2

vec3

param v2

Third of the three counter-clockwise triangle vertices

type segments

int, optional

param segments

Number of subdivisions along each edge.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_spring(*args, **kwargs)

Creates a spring aligned along the z-axis and with a counter-clockwise winding.

type name

string

param name

The name (used as a primary key) for this mesh component

type minor

float, optional

param minor

Radius of the spring it self.

type major

float, optional

param major

Radius from the z-axis

type size

float, optional

param size

Half of the length along the z-axis.

type slices

int, optional

param slices

Subdivisions around the spring.

type segments

int, optional

param segments

Subdivisions along the path.

type majorStart

float, optional

param majorStart

Counterclockwise angle around the z-axis relative to the x-axis.

type majorSweep

float, optional

param majorSweep

Counterclockwise angle around the z-axis.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_teapotahedron(name, segments=8)

Creates the Utah Teapot using the original b-spline surface data. (https://en.wikipedia.org/wiki/Utah_teapot)

The lid is points towards the z axis and the spout points towards the x axis.

type name: string
param name: The name (used as a primary key) for this mesh component
type segments: int, optional
param segments: The number segments along each patch. Should be >= 1. If zero empty mesh is generated.
rtype: Mesh
return: a reference to the mesh component

nvisii.mesh_create_torus(*args, **kwargs)

Creates a torus centered at the origin and along the xy-plane.

type name

string

param name

The name (used as a primary key) for this mesh component

type minor

float, optional

param minor

Radius of the minor (inner) ring

type major

float, optional

param major

Radius of the major (outer) ring

type slices

int, optional

param slices

Subdivisions around the minor ring

type segments

int, optional

param segments

Subdivisions around the major ring

type minorStart

float, optional

param minorStart

Counterclockwise angle relative to the xy-plane.

type minorSweep

float, optional

param minorSweep

Counterclockwise angle around the circle.

type majorStart

float, optional

param majorStart

Counterclockwise angle around the z-axis relative to the x-axis.

type majorSweep

float, optional

param majorSweep

Counterclockwise angle around the z-axis.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_torus_knot(name, p=2, q=3, slices=8, segments=96)

Creates a circle extruded along the path of a knot. (https://en.wikipedia.org/wiki/Torus_knot)

type name

string

param name

The name (used as a primary key) for this mesh component

type p

int, optional

param p

First coprime integer.

type q

int, optional

param q

Second coprime integer.

type slices

int, optional

param slices

Number subdivisions around the circle.

type segments

int, optional

param segments

Number of subdivisions around the path.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_triangle(name, v0, v1, v2, segments=4)

Creates a triangle from the specified vertices

type name

string

param name

The name (used as a primary key) for this mesh component

type v0

vec3

param v0

First of the vertex positions of the triangle.

type v1

vec3

param v1

Second of the vertex positions of the triangle.

type v2

vec3

param v2

Third of the vertex positions of the triangle.

type segments

int, optional

param segments

The number of segments along each edge. Must be >= 1.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_triangle_from_circumscribed_circle(name, radius=1.0, segments=4)

Creates a triangle centered at the origin and contained within the circumscribed circle.

type name

string

param name

The name (used as a primary key) for this mesh component

type radius

float, optional

param radius

The radius of the containing circle.

type segments

int, optional

param segments

The number of segments along each edge. Must be >= 1.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_tube(*args, **kwargs)

Creates an uncapped tube (a cylinder with thickness) centered at the origin and aligned along the z-axis.

type name

string

param name

The name (used as a primary key) for this mesh component

type radius

float, optional

param radius

The outer radius of the cylinder on the xy-plane.

type innerRadius

float, optional

param innerRadius

The inner radius of the cylinder on the xy-plane.

type size

float, optional

param size

Half of the length of the cylinder along the z-axis.

type slices

int, optional

param slices

Subdivisions around the z-axis.

type segments

int, optional

param segments

Subdivisions along the z-axis.

type start

float, optional

param start

Counterclockwise angle around the z-axis relative to the x-axis.

type sweep

float, optional

param sweep

Counterclockwise angle around the z-axis.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_tube_from_polyline(name, path, radius=1.0, segments=16)

Creates a tube from a circle extruded linearly along the specified path.

type name

string

param name

The name (used as a primary key) for this mesh component

type path

std::vector< glm::vec3,std::allocator< glm::vec3 > >

param path

A set of vertices describing a linear path.

type radius

float, optional

param radius

The radius of the extruded circle

type segments

int, optional

param segments

Number of subdivisions around the circle.

rtype

Mesh

return

a reference to the mesh component

nvisii.mesh_create_wireframe_bounding_box(*args, **kwargs)

Creates a wireframe bounding box spanning the region between the minimum corner to the maximum corner, and aligned along the x, y, and z axis.

Parameters

name (string) – The name (used as a primary key) for this mesh component
min_corner (vec3, optional) – The position of the bottom left near corner of the axis aligned bounding box.
max_corner (vec3, optional) – The position of the top right far corner of the axis aligned bounding box.
size – The side length in x (0), y (1) and z (2) direction.
thickness (float, optional) – The thickness of the wires in the wireframe.

Return type

Mesh

Returns

a reference to the mesh component

nvisii.mesh_get(name)

Parameters: name (string) – The name of the Mesh to get
Return type: Mesh
Returns: a Mesh who’s name matches the given name

nvisii.mesh_get_count()

Return type: int
Returns: the number of allocated meshes

nvisii.mesh_get_dirty_meshes()

Return type: std::set< nvisii::Mesh * >
Returns: a list of meshes that have been modified since the previous frame

nvisii.mesh_get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing by the renderer.

nvisii.mesh_get_front()

Return type: Mesh
Returns: a pointer to the table of mesh components

nvisii.mesh_get_front_struct()

Return type: MeshStruct
Returns: a pointer to the table of MeshStructs required for rendering

nvisii.mesh_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a mesh name and whose value is the ID for that mesh

nvisii.mesh_initialize_factory(max_components): Allocates the tables used to store all mesh components

nvisii.mesh_is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all mesh components have been allocated, and False otherwise

nvisii.mesh_remove(name)

Parameters: name (string) – The name of the Mesh to remove

nvisii.mesh_update_components(): Iterates through all mesh components, computing mesh metadata for rendering purposes.

nvisii.min(arg1, arg2) → float

arg1: float const & arg2: float const &

min(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

min(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

min(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

min(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: float const &

min(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: float const &

min(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: float const &

nvisii.mix(x, y, a) → quat

x: glm::quat const & y: glm::quat const & a: float

mix(arg1, arg2, arg3) -> float

arg1: float const & arg2: float const & arg3: float const &

mix(arg1, arg2, arg3) -> float

arg1: float const & arg2: float const & arg3: bool const &

mix(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const &

mix(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

mix(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: glm::vec4 const &

mix(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: bool const &

mix(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: bool const &

mix(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: bool const &

nvisii.mod(arg1, arg2) → float

arg1: float const & arg2: float const &

mod(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

mod(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

mod(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

mod(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: float const &

mod(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: float const &

mod(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: float const &

nvisii.modf(arg1, arg2) → float

arg1: float const & arg2: float &

modf(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 &

modf(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 &

modf(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 &

nvisii.normalize(q) → quat

q: glm::quat const &

normalize(arg1) -> vec2

arg1: glm::vec2 const &

normalize(arg1) -> vec3

arg1: glm::vec3 const &

normalize(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.one() → float

nvisii.one_over_pi() → float

nvisii.one_over_root_two() → float

nvisii.orientation(arg1, arg2) → mat4: arg1: glm::vec3 const & arg2: glm::vec3 const &

nvisii.orientedAngle(arg1, arg2) → float

arg1: glm::vec2 const & arg2: glm::vec2 const &

orientedAngle(arg1, arg2, arg3) -> float

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

nvisii.ortho(arg1, arg2, arg3, arg4) → mat4

arg1: float const & arg2: float const & arg3: float const & arg4: float const &

ortho(arg1, arg2, arg3, arg4, arg5, arg6) -> mat4

arg1: float const & arg2: float const & arg3: float const & arg4: float const & arg5: float const & arg6: float const &

nvisii.outerProduct(arg1, arg2) → mat3

arg1: glm::vec3 const & arg2: glm::vec3 const &

outerProduct(arg1, arg2) -> mat4

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.perp(arg1, arg2) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

perp(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

nvisii.perspective(arg1, arg2, arg3, arg4) → mat4: arg1: float const & arg2: float const & arg3: float const & arg4: float const &

nvisii.perspectiveFov(arg1, arg2, arg3, arg4, arg5) → mat4: arg1: float const & arg2: float const & arg3: float const & arg4: float const & arg5: float const &

nvisii.pi() → float

nvisii.pickMatrix(arg1, arg2, arg3) → mat4: arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec4 const &

nvisii.pitch(x) → float: x: glm::quat const &

nvisii.pow(arg1, arg2) → float

arg1: float const & arg2: float const &

pow(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

pow(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

pow(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.project(arg1, arg2, arg3, arg4) → vec3: arg1: glm::vec3 const & arg2: glm::mat4 const & arg3: glm::mat4 const & arg4: glm::vec4 const &

nvisii.quarter_pi() → float

class nvisii.quat(*args)

Proxy of C++ glm::quat class.

static length() → glm::length_t

property thisown: The membership flag

property w

property x

property y

property z

nvisii.quat_cast(x) → quat

x: glm::mat3 const &

quat_cast(x) -> quat

x: glm::mat4 const &

nvisii.quat_length() → glm::length_t

nvisii.radians(arg1) → float

arg1: float const &

radians(arg1) -> vec2

arg1: glm::vec2 const &

radians(arg1) -> vec3

arg1: glm::vec3 const &

radians(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.reflect(arg1, arg2) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

reflect(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

reflect(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

nvisii.refract(arg1, arg2, arg3) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: float const &

refract(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: float const &

refract(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: float const &

nvisii.register_callback(callback): Registers a callback which is called on the render thread before each rendered frame. This mechanism is useful for implementing camera controls and other routines dependent on cursor and button clicks. To disable the callback, pass nullptr/None here.

nvisii.render(width, height, samples_per_pixel, seed=0)

Renders the current scene, returning the resulting framebuffer back to the user directly.

Parameters

width (int) – The width of the image to render
height (int) – The height of the image to render
samples_per_pixel (int) – The number of rays to trace and accumulate per pixel.
seed (int, optional) – A seed used to initialize the random number generator.

nvisii.render_data(width, height, start_frame, frame_count, bounce, options, seed=0)

Renders out metadata used to render the current scene, returning the resulting framebuffer back to the user directly.

Parameters

width (int) – The width of the image to render
height (int) – The height of the image to render
start_frame (int) – The start seed to feed into the random number generator
frame_count (int) – The number of frames to accumulate the resulting framebuffers by. For ID data, this should be set to 0.
bounce (int) – The number of bounces required to reach the vertex whose metadata result should come from. A value of 0 would save data for objects directly visible to the camera, a value of 1 would save reflections/refractions, etc.
options (string) – Indicates the data to return. Current possible values include “none” for rendering out raw path traced data, “depth” to render the distance between the previous path vertex to the current one, “ray_direction” to render the direction that the ray was traced in world space, “position” for rendering out the world space position of the path vertex, “normal” for rendering out the world space normal of the path vertex, “tangent” for rendering out the world space tangent of the path vertex, “entity_id” for rendering out the entity ID whose surface the path vertex hit, “base_color” for rendering out the surface base color, “texture_coordinates” for rendering out the texture coordinates of the hit surface, “screen_space_normal” for rendering out the normals of the hit surface in screen space, “diffuse_motion_vectors” for rendering out screen space motion vectors for moving objects, “denoise_normal” for rendering out the normal buffer supplied to the Optix denoiser, “denoise_albedo” for rendering out the albedo supplied to the Optix denoiser, “heatmap” for rendering out the time it takes to render out each pixel, “device_id” for determining which GPU was used to render what pixel.
seed (int, optional) – A seed used to initialize the random number generator.

nvisii.render_data_to_file(width, height, start_frame, frame_count, bounce, options, file_path, seed=0)

Renders out metadata used to render the current scene, returning the resulting framebuffer back to the user directly.

Parameters

width (int) – The width of the image to render
height (int) – The height of the image to render
start_frame (int) – The start seed to feed into the random number generator
frame_count (int) – The number of frames to accumulate the resulting framebuffers by. For ID data, this should be set to 0.
bounce (int) – The number of bounces required to reach the vertex whose metadata result should come from. A value of 0 would save data for objects directly visible to the camera, a value of 1 would save reflections/refractions, etc.
options (string) – Indicates the data to return. Current possible values include “none” for rendering out raw path traced data, “depth” to render the distance between the previous path vertex to the current one, “ray_direction” to render the direction that the ray was traced in world space, “position” for rendering out the world space position of the path vertex, “normal” for rendering out the world space normal of the path vertex, “entity_id” for rendering out the entity ID whose surface the path vertex hit, “base_color” for rendering out the surface base color, “texture_coordinates” for rendering out the texture coordinates of the hit surface, “screen_space_normal” for rendering out the normals of the hit surface in screen space, “diffuse_motion_vectors” for rendering out screen space motion vectors for moving objects, “denoise_normal” for rendering out the normal buffer supplied to the Optix denoiser, “denoise_albedo” for rendering out the albedo supplied to the Optix denoiser, “heatmap” for rendering out the time it takes to render out each pixel, “device_id” for determining which GPU was used to render what pixel.
file_path (string) – The path to use to save the file, including the extension. Supported extensions are EXR, HDR, and PNG
seed (int, optional) – A seed used to initialize the random number generator.

nvisii.render_to_file(width, height, samples_per_pixel, file_path, seed=0)

Renders the current scene, saving the resulting framebuffer to an image on disk.

Parameters

width (int) – The width of the image to render
height (int) – The height of the image to render
samples_per_pixel (int) – The number of rays to trace and accumulate per pixel.
file_path (string) – The path to use to save the file, including the extension. Supported extensions include EXR, HDR, and PNG
seed (int, optional) – A seed used to initialize the random number generator.

nvisii.render_to_hdr(width, height, samples_per_pixel, image_path, seed=0): Deprecated. Please use renderToFile.

nvisii.render_to_png(width, height, samples_per_pixel, image_path, seed=0): Deprecated. Please use renderToFile.

nvisii.resize_window(width, height)

If using interactive mode, resizes the window to the specified dimensions.

Parameters

width (int) – The width to resize the window to
height (int) – The height to resize the window to

nvisii.roll(x) → float: x: glm::quat const &

nvisii.root_five() → float

nvisii.root_half_pi() → float

nvisii.root_ln_four() → float

nvisii.root_pi() → float

nvisii.root_three() → float

nvisii.root_two() → float

nvisii.root_two_pi() → float

nvisii.rotate(q, angle, axis) → quat

q: glm::quat const & angle: float const & axis: glm::vec3 const &

rotate(arg1, arg2, arg3) -> mat4

arg1: glm::mat4 const & arg2: float const & arg3: glm::vec3 const &

rotate(arg1, arg2) -> vec2

arg1: glm::vec2 const & arg2: float const &

rotate(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: float const & arg3: glm::vec3 const &

rotate(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: float const & arg3: glm::vec3 const &

rotate(angle, arg2) -> mat4

angle: float arg2: glm::vec3 const &

nvisii.rotateX(arg1, arg2) → vec3

arg1: glm::vec3 const & arg2: float const &

rotateX(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: float const &

nvisii.rotateY(arg1, arg2) → vec3

arg1: glm::vec3 const & arg2: float const &

rotateY(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: float const &

nvisii.rotateZ(arg1, arg2) → vec3

arg1: glm::vec3 const & arg2: float const &

rotateZ(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: float const &

nvisii.round(arg1) → float

arg1: float const &

round(arg1) -> vec2

arg1: glm::vec2 const &

round(arg1) -> vec3

arg1: glm::vec3 const &

round(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.roundEven(arg1) → float

arg1: float const &

roundEven(arg1) -> vec2

arg1: glm::vec2 const &

roundEven(arg1) -> vec3

arg1: glm::vec3 const &

roundEven(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.row(arg1, arg2) → vec3

arg1: glm::mat3 const & arg2: glm::length_t const &

row(arg1, arg2) -> vec4

arg1: glm::mat4 const & arg2: glm::length_t const &

row(arg1, arg2, arg3) -> mat3

arg1: glm::mat3 const & arg2: glm::length_t const & arg3: glm::vec3 const &

row(arg1, arg2, arg3) -> mat4

arg1: glm::mat4 const & arg2: glm::length_t const & arg3: glm::vec4 const &

nvisii.sample_pixel_area(*args, **kwargs)

Sets the region of the pixel where rays should sample. By default, rays sample the entire pixel area between [0,1]. Rays can instead sample a specific location of the pixel, like the pixel center, by specifying a specific location within the pixel area, eg [.5, .5]. This allows for enabling or disabling antialiasing, possibly at the cost of noise in intermediate data buffers.

Parameters

x_sample_interval (vec2, optional) – The interval to sample rays within along the x axis. A value of [0,1] will sample the entire pixel x axis.
y_sample_interval (vec2, optional) – The interval to sample rays within along the y axis. A value of [0,1] will sample the entire pixel y axis.

nvisii.sample_time_interval(*args, **kwargs)

Sets the interval of time that rays should sample. By default, rays sample the entire time interval befween the current frame and the next, [0,1]. Rays can instead sample a specific point in time, like the end-of-frame time, by specifying a specific location within the time interval, eg [1.0, 1.0] or [0.0, 0.0]. This allows for enabling or disabling motion blur, while still preserving motion vectors.

Parameters: time_sample_interval (vec2, optional) – The interval to sample rays within along in time. A value of [0,1] will result in motion blur across the entire frame.

nvisii.saturate(arg1) → vec2

arg1: glm::vec2 const &

saturate(arg1) -> vec3

arg1: glm::vec3 const &

saturate(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.scale(arg1, arg2) → mat4

arg1: glm::mat4 const & arg2: glm::vec3 const &

scale(arg1) -> mat4

arg1: glm::vec3 const &

class nvisii.scene

An object containing a list of components that together represent a scene

property thisown: The membership flag

nvisii.set_camera_entity(camera_entity)

Tells the renderer which camera entity to use for rendering. The transform component of this camera entity places the camera into the world, and the camera component of this camera entity describes the perspective to use, the field of view, the depth of field, and other “analog” camera properties.

Parameters: camera_entity (Entity) – The entity containing a camera and transform component, to use for rendering.

nvisii.set_cursor_mode(mode): If in interactive mode, sets the mode of the cursor. :type mode: string :param mode: Can be one of the following:

NORMAL - makes the cursor visible and beaving normally HIDDEN makes the cursor invisible when it is over the content area of the window, but does not restrict the cursor from leaving. DISABLED - hides and grabs the cursor, providing virtual and unlimited cursor movement. This is useful for implementing for example 3D camera controls.

nvisii.set_direct_lighting_clamp(clamp)

Clamps the direct light intensity during progressive image refinement. This reduces fireflies from direct lighting, but also removes energy, and biases the resulting image.

Parameters: clamp (float) – The maximum intensity that direct lighting can contribute per frame. A value of 0 disables direct light clamping.

nvisii.set_dome_light_color(color)

Sets the color which this dome light will emit.

Parameters: The – RGB color emitted that this dome light should emit.

nvisii.set_dome_light_exposure(exposure)

Modifies the intensity, or brightness, that the dome light (aka environment light) will emit it’s color. Increasing the exposure by 1 will double the energy emitted by the light. An exposure of 0 produces an unmodified intensity. An exposure of -1 cuts the intensity of the light in half. light_intensity = intensity * pow(2, exposureExposure)

Parameters: exposure (float) – How powerful the light source is in emitting light.

nvisii.set_dome_light_intensity(intensity)

Sets the intensity, or brightness, that the dome light (aka environment light) will emit it’s color.

Parameters: intensity (float) – How powerful the dome light is in emitting light

nvisii.set_dome_light_rotation(rotation)

Sets the rotation to apply to the dome light (aka the environment).

Parameters: rotation (quat) – The rotation to apply to the dome light

nvisii.set_dome_light_sky(*args, **kwargs)

Configures the procedural sky for the dome light (aka the environment). :type sun_position: vec3 :param sun_position: The position of the sun relative to [0,0,0]. As the sun

goes down (in Z), Rayleigh scattering will cause the sky to change colors.

Parameters

sky_tint (vec3, optional) – controls the relative color of the sky before Rayleigh scattering.
atmosphere_thickness (float, optional) – effects Rayleigh scattering. Thin atmospheres look more like space, and thick atmospheres see more Rayleigh scattering.
saturation (float, optional) – causes the sky to appear more or less “vibrant”

nvisii.set_dome_light_texture(texture, enable_cdf=False)

Sets the texture used to color the dome light (aka the environment). Textures are sampled using a 2D to 3D latitude/longitude strategy.

Parameters

texture (Texture) – The texture to sample for the dome light.
enable_cdf (boolean, optional) – If True, reduces noise of sampling a dome light texture, but at the expense of frame rate. Useful for dome lights with bright lights that should cast shadows.

nvisii.set_indirect_lighting_clamp(clamp)

Clamps the indirect light intensity during progressive image refinement. This reduces fireflies from indirect lighting, but also removes energy, and biases the resulting image.

Parameters: clamp (float) – The maximum intensity that indirect lighting can contribute per frame. A value of 0 disables indirect light clamping.

nvisii.set_light_sample_count(count)

Sets the number of light samples to take per path vertex. A higher number of samples will reduce noise per frame, but also reduces frames per second.

Parameters: count (int) – The number of light samples to take per path vertex. Currently constrained to a maximum of 10 samples per vertex.

nvisii.set_max_bounce_depth(diffuse_depth=2, glossy_depth=8, transparency_depth=8, transmission_depth=12, volume_depth=2)

Sets the maximum number of times that a ray originating from the camera can bounce through the scene to accumulate light. For scenes containing only rough surfaces, this max bounce depth can be set to lower values. For scenes containing complex transmissive or reflective objects like glass or metals, this max bounce depth might need to be increased to accurately render these objects.

Parameters

diffuse_depth (int, optional) – The maximum number of diffuse bounces allowed per ray. Higher counts will increase global illumination effects.
glossy_depth (int, optional) – The maximum number of glossy (reflection) bounces allowed per ray. Increases recursion in setups with mirrors, shiny surfaces, metals, etc
transparency_depth (int, optional) – The maximum number of transparency (alpha) bounces allowed per ray. Used for alpha cutouts of folliage and alpha transparent objects.
transmission_depth (int, optional) – The maximum number of transmission (refraction) bounces allowed per ray. For scenes containing glass, higher transmission depths result in more realistic refractions.
volume_depth (int, optional) – The maximum number of volume bounces allowed per ray. At 0, volumes are single-scattering. Higher values result in multiple scattering.

nvisii.should_window_close(): If in interactive mode, returns true if the close button on the window was clicked.

nvisii.sign(arg1) → float

arg1: float const &

sign(arg1) -> vec2

arg1: glm::vec2 const &

sign(arg1) -> vec3

arg1: glm::vec3 const &

sign(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.sin(arg1) → float

arg1: float const &

sin(arg1) -> vec2

arg1: glm::vec2 const &

sin(arg1) -> vec3

arg1: glm::vec3 const &

sin(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.sinh(arg1) → float

arg1: float const &

sinh(arg1) -> vec2

arg1: glm::vec2 const &

sinh(arg1) -> vec3

arg1: glm::vec3 const &

sinh(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.slerp(x, y, a) → quat

x: glm::quat const & y: glm::quat const & a: float

slerp(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: float const &

nvisii.smoothstep(arg1, arg2, arg3) → float

arg1: float const & arg2: float const & arg3: float const &

smoothstep(arg1, arg2, arg3) -> vec2

arg1: glm::vec2 const & arg2: glm::vec2 const & arg3: glm::vec2 const &

smoothstep(arg1, arg2, arg3) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const & arg3: glm::vec3 const &

smoothstep(arg1, arg2, arg3) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const & arg3: glm::vec4 const &

smoothstep(arg1, arg2, arg3) -> vec2

arg1: float const & arg2: float const & arg3: glm::vec2 const &

smoothstep(arg1, arg2, arg3) -> vec3

arg1: float const & arg2: float const & arg3: glm::vec3 const &

smoothstep(arg1, arg2, arg3) -> vec4

arg1: float const & arg2: float const & arg3: glm::vec4 const &

nvisii.sqrt(arg1) → vec2

arg1: glm::vec2 const &

sqrt(arg1) -> vec3

arg1: glm::vec3 const &

sqrt(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.step(arg1, arg2) → vec2

arg1: glm::vec2 const & arg2: glm::vec2 const &

step(arg1, arg2) -> vec3

arg1: glm::vec3 const & arg2: glm::vec3 const &

step(arg1, arg2) -> vec4

arg1: glm::vec4 const & arg2: glm::vec4 const &

step(arg1, arg2) -> vec2

arg1: float const & arg2: glm::vec2 const &

step(arg1, arg2) -> vec3

arg1: float const & arg2: glm::vec3 const &

step(arg1, arg2) -> vec4

arg1: float const & arg2: glm::vec4 const &

nvisii.tan(arg1) → float

arg1: float const &

tan(arg1) -> vec2

arg1: glm::vec2 const &

tan(arg1) -> vec3

arg1: glm::vec3 const &

tan(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.tanh(arg1) → float

arg1: float const &

tanh(arg1) -> vec2

arg1: glm::vec2 const &

tanh(arg1) -> vec3

arg1: glm::vec3 const &

tanh(arg1) -> vec4

arg1: glm::vec4 const &

class nvisii.texture(*args, **kwargs)

The “Texture” component describes a 2D pattern used to drive the “Material” component’s parameters.

static are_any_dirty(): Indicates whether or not any entities are “out of date” and need to be updated through the “update components” function

static clear_all(): Clears any existing Texture components.

static create_add(name, a, b, hdr=False): Constructs a Texture with the given name that adds two different textures together. :type name: string :param name: The name of the texture to create. :type a: Texture :param a: The first of two textures to add. :type b: Texture :param b: The second of two textures to add. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

static create_from_data(name, width, height, data, linear=True, hdr=False): Constructs a Texture with the given name from custom user data. :type name: string :param name: The name of the texture to create. :type width: int :param width: The width of the image. :type height: int :param height: The height of the image. :type data: float :param data: A row major flattened vector of RGBA texels. The length of this vector should be 4 * width * height. :type linear: boolean, optional :param linear: Indicates the image is already linear and should not be gamma corrected. Note, defaults to True for this function. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

static create_from_file(name, path, linear=False)

Constructs a Texture with the given name from a file. :type name: string :param name: The name of the texture to create.

Supported formats include JPEG, PNG, TGA, BMP, PSD, GIF, HDR, PIC, PNM, KTX, and DDS

Parameters

path (string) – The path to the image.
linear (boolean, optional) – Indicates the image is already linear and should not be gamma corrected. Ignored for KTX, DDS, and HDR formats.

Return type

Texture

Returns

a Texture allocated by the renderer.

static create_from_image(name, path, linear=False): Deprecated. Please use createFromFile.

static create_hsv(name, tex, hue, saturation, value, mix=1.0, hdr=False)

Constructs a Texture with the given name by applying a color transformation on the HSV space to an existing texture. :type name: string :param name: The name of the texture to create. :param t: The texture to take pixels from :type hue: float :param hue: Specifies the hue rotation of the image. 360 degrees are mapped to [0,1].

The hue shifts of 0 (-180) and 1 (180) have the same result.

Parameters

saturation (float) – A saturation of 0 removes hues from the image, resulting in a grayscale image. A shift greater than 1.0 increases saturation.
value (float) – is the overall brightness of the image. De/Increasing values shift an image darker/lighter.
mix (float, optional) – A value between 0 and 1 used to mix between the original input and the HSV transformed image.
hdr (boolean, optional) – If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel.

Return type

Texture

Returns

a Texture allocated by the renderer.

static create_mix(name, a, b, mix=1.0, hdr=False): Constructs a Texture with the given name that mixes two different textures together. :type name: string :param name: The name of the texture to create. :type a: Texture :param a: The first of two textures to mix. :type b: Texture :param b: The second of two textures to mix. :type mix: float, optional :param mix: A value between 0 and 1 used to mix between the first and second textures. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

static create_multiply(name, a, b, hdr=False): Constructs a Texture with the given name that multiplies two different textures together. :type name: string :param name: The name of the texture to create. :type a: Texture :param a: The first of two textures to multiply. :type b: Texture :param b: The second of two textures to multiply. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

static get(name)

Parameters: name (string) – The name of the Texture to get
Return type: Texture
Returns: a Texture who’s name matches the given name

get_byte_texels()

Return type: std::vector< u8vec4,std::allocator< u8vec4 > >
Returns: a flattened list of 8-bit texels

static get_count()

Return type: int
Returns: the number of allocated textures

static get_dirty_textures()

Return type: std::set< nvisii::Texture * >
Returns: a list of textures that have been modified since the previous frame

static get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing by the renderer.

get_float_texels()

Return type: std::vector< vec4,std::allocator< vec4 > >
Returns: a flattened list of 32-bit float texels

static get_front()

Return type: Texture
Returns: a pointer to the table of Texture components

static get_front_struct()

Return type: TextureStruct
Returns: a pointer to the table of TextureStructs

get_height()

Return type: int
Returns: the height of the texture in texels

get_id()

Return type: int
Returns: the unique integer ID for this component

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a texture name and whose value is the ID for that texture

get_width()

Return type: int
Returns: the width of the texture in texels

static initialize_factory(max_components): Allocates the tables used to store all Texture components

static is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all Texture components have been allocated, and False otherwise

is_hdr()

Return type: boolean
Returns: True if the texture contains any values above 1

is_initialized()

Return type: boolean
Returns: True the current Texture is a valid, initialized Texture, and False if the Texture was cleared or removed.

is_linear()

Return type: boolean
Returns: True if the texture is represented linearly. Otherwise, the texture is in sRGB space

mark_dirty(): Tags the current component as being modified since the previous frame.

static remove(name)

Parameters: name (string) – The name of the Texture to remove

sample_byte_texels(uv): Sample the texture at the given texture coordinates :type uv: vec2 :param uv: A pair of values between [0,0] and [1,1] :rtype: u8vec4 :return: a sampled texture value

sample_float_texels(uv): Sample the texture at the given texture coordinates :type uv: vec2 :param uv: A pair of values between [0,0] and [1,1] :rtype: vec4 :return: a sampled texture value

set_linear(is_linear)

Parameters: is_linear (boolean) – If True, texels will be interpreted as linear space. Otherwise, the texels will be interpreed as sRGB space

set_scale(scale): Sets the “scale” of a texture. Useful for patterns that repeat, eg tiles. Under the hood, this scales the texture coordinates of the object this texture influences. :type scale: vec2 :param scale: The scale of the texture. A value of [.5,.5] will cause a texture to take

up half the footprint in UV space of the original texture, effectively causing the texture to repeat in a pattern. Textures can be flipped in either U and/or V using negative scales.

property thisown: The membership flag

to_string()

Return type: string
Returns: a json string representation of the current component

static update_components(): Iterates through all components, updating any component struct fields and marking components as clean.

nvisii.texture_are_any_dirty(): Indicates whether or not any entities are “out of date” and need to be updated through the “update components” function

nvisii.texture_clear_all(): Clears any existing Texture components.

nvisii.texture_create_add(name, a, b, hdr=False): Constructs a Texture with the given name that adds two different textures together. :type name: string :param name: The name of the texture to create. :type a: Texture :param a: The first of two textures to add. :type b: Texture :param b: The second of two textures to add. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

nvisii.texture_create_from_data(name, width, height, data, linear=True, hdr=False): Constructs a Texture with the given name from custom user data. :type name: string :param name: The name of the texture to create. :type width: int :param width: The width of the image. :type height: int :param height: The height of the image. :type data: float :param data: A row major flattened vector of RGBA texels. The length of this vector should be 4 * width * height. :type linear: boolean, optional :param linear: Indicates the image is already linear and should not be gamma corrected. Note, defaults to True for this function. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

nvisii.texture_create_from_file(name, path, linear=False)

Constructs a Texture with the given name from a file. :type name: string :param name: The name of the texture to create.

Supported formats include JPEG, PNG, TGA, BMP, PSD, GIF, HDR, PIC, PNM, KTX, and DDS

Parameters

path (string) – The path to the image.
linear (boolean, optional) – Indicates the image is already linear and should not be gamma corrected. Ignored for KTX, DDS, and HDR formats.

Return type

Texture

Returns

a Texture allocated by the renderer.

nvisii.texture_create_from_image(name, path, linear=False): Deprecated. Please use createFromFile.

nvisii.texture_create_hsv(name, tex, hue, saturation, value, mix=1.0, hdr=False)

Constructs a Texture with the given name by applying a color transformation on the HSV space to an existing texture. :type name: string :param name: The name of the texture to create. :param t: The texture to take pixels from :type hue: float :param hue: Specifies the hue rotation of the image. 360 degrees are mapped to [0,1].

The hue shifts of 0 (-180) and 1 (180) have the same result.

Parameters

saturation (float) – A saturation of 0 removes hues from the image, resulting in a grayscale image. A shift greater than 1.0 increases saturation.
value (float) – is the overall brightness of the image. De/Increasing values shift an image darker/lighter.
mix (float, optional) – A value between 0 and 1 used to mix between the original input and the HSV transformed image.
hdr (boolean, optional) – If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel.

Return type

Texture

Returns

a Texture allocated by the renderer.

nvisii.texture_create_mix(name, a, b, mix=1.0, hdr=False): Constructs a Texture with the given name that mixes two different textures together. :type name: string :param name: The name of the texture to create. :type a: Texture :param a: The first of two textures to mix. :type b: Texture :param b: The second of two textures to mix. :type mix: float, optional :param mix: A value between 0 and 1 used to mix between the first and second textures. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

nvisii.texture_create_multiply(name, a, b, hdr=False): Constructs a Texture with the given name that multiplies two different textures together. :type name: string :param name: The name of the texture to create. :type a: Texture :param a: The first of two textures to multiply. :type b: Texture :param b: The second of two textures to multiply. :type hdr: boolean, optional :param hdr: If true, represents the channels of the texture using 32 bit floats. Otherwise, textures are stored natively using 8 bits per channel. :rtype: Texture :return: a Texture allocated by the renderer.

nvisii.texture_get(name)

Parameters: name (string) – The name of the Texture to get
Return type: Texture
Returns: a Texture who’s name matches the given name

nvisii.texture_get_count()

Return type: int
Returns: the number of allocated textures

nvisii.texture_get_dirty_textures()

Return type: std::set< nvisii::Texture * >
Returns: a list of textures that have been modified since the previous frame

nvisii.texture_get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing by the renderer.

nvisii.texture_get_front()

Return type: Texture
Returns: a pointer to the table of Texture components

nvisii.texture_get_front_struct()

Return type: TextureStruct
Returns: a pointer to the table of TextureStructs

nvisii.texture_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a texture name and whose value is the ID for that texture

nvisii.texture_initialize_factory(max_components): Allocates the tables used to store all Texture components

nvisii.texture_is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all Texture components have been allocated, and False otherwise

nvisii.texture_remove(name)

Parameters: name (string) – The name of the Texture to remove

nvisii.texture_update_components(): Iterates through all components, updating any component struct fields and marking components as clean.

nvisii.third() → float

class nvisii.transform(*args, **kwargs)

The “Transform” component places an entity into the scene. These transform components represent a scale, a rotation, and a translation, in that order. These transform components also keep track of the previous frame scale, rotation, and translation, which can optionally be used for creating motion blur and for temporal effects like reprojection.

add_angle_axis(angle, axis, previous=False)

Adds a rotation to the existing transform rotation from local to parent using an axis in local space to rotate about, and an angle in radians to drive the rotation

Parameters

angle (float) – The angle (in radians) to rotate the current transform quaterion by.
axis (vec3) – The axis to rotate about.
previous (boolean, optional) – If true, edits the previous rotation.

add_child(child)

Add a child to this transform, whose transformation will be applied before the current transform.

Parameters: child (Transform) – The child transform component to constrain to the current transform. Any existing parent constraint is replaced.

add_position(additionalPosition, previous=False)

Adds to the current the position vector describing where this transform should be translated to when placed in its parent space.

Parameters

additionalPosition (vec3) – The position (interpreted as a vector) to add onto the current transform position.
previous (boolean, optional) – If true, edits the previous position.

add_rotation(additionalRotation, previous=False)

Adds a rotation to the existing transform rotation from local to parent via a quaternion.

Parameters

additionalRotation (quat) – The rotation quaternion apply to the existing transform quaternion.
previous (boolean, optional) – If true, edits the previous rotation.

add_scale(additionalScale, previous=False)

Adds to the current the scale of this transform from local to parent space along its right, up, and forward directions respectively

Parameters

additionalScale (vec3) – The scale to add onto the current transform scale.
previous (boolean, optional) – If true, edits the previous scale.

static are_any_dirty()

Return type: boolean
Returns: True if any the transform has been modified since the previous frame, and False otherwise

static clear_all(): Clears any existing transform components.

clear_motion(): Resets any “previous” transform data, effectively clearing any current motion blur.

clear_parent(): Removes the parent-child relationship affecting this node.

static create(*args, **kwargs)

Constructs a transform with the given name.

Parameters

name (string) – A unique name for this transform.
scale (vec3, optional) – The initial scale of the transform, applied first.
rotation (quat, optional) – The initial scale of the transform, applied after scale.
position (vec3, optional) – The initial position of the transform, applied after rotation.

Return type

Transform

Returns

a reference to a transform component

static create_from_matrix(*args, **kwargs)

Constructs a transform with the given name, initializing with the given matrix.

Parameters

name (string) – A unique name for this transform.
matrix – The initial local to world transformation to be applied

Return type

Transform

Returns

a reference to a transform component

static get(name)

Parameters: name (string) – The name of the transform to get
Return type: Transform
Returns: a transform who’s name matches the given name

static get_count()

Return type: int
Returns: the number of allocated transforms

static get_dirty_transforms()

Return type: std::set< nvisii::Transform * >
Returns: a list of transforms that have been modified since the previous frame

get_forward(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-space forward vector.
Return type: vec3
Returns: a vector pointing forward relative to the current transform placed in its’ parent’s space.

get_id()

Return type: int
Returns: the unique integer ID for this component

get_local_to_parent_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous local-to-parent matrix.
Return type: mat4
Returns: the final matrix transforming this object from it’s local coordinate space to it’s parents coordinate space

get_local_to_parent_rotation_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous local-to-parent rotation matrix.
Return type: mat4
Returns: the final matrix rotating this object in it’s local coordinate space to it’s parent coordinate space

get_local_to_parent_scale_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous local-to-parent scale matrix.
Return type: mat4
Returns: the final matrix translating this object from it’s local coordinate space to it’s parent coordinate space

get_local_to_parent_translation_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous local-to-parent translation matrix.
Return type: mat4
Returns: the final matrix translating this object from it’s local coordinate space to it’s parent coordinate space

get_local_to_world_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous local-to-world matrix.
Return type: mat4
Returns: a matrix transforming this component from its local space to world space, taking all parent transforms into account.

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a transform name and whose value is the ID for that transform

get_parent_to_local_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-to-local matrix.
Return type: mat4
Returns: the final matrix transforming this object from it’s parent coordinate space to it’s local coordinate space

get_parent_to_local_rotation_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-to-local rotation matrix.
Return type: mat4
Returns: the final matrix rotating this object from it’s parent coordinate space to it’s local coordinate space

get_parent_to_local_scale_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-to-local scale matrix.
Return type: mat4
Returns: the final matrix scaling this object from it’s parent coordinate space to it’s local coordinate space

get_parent_to_local_translation_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-to-local translation matrix.
Return type: mat4
Returns: the final matrix translating this object from it’s parent coordinate space to it’s local coordinate space

get_position(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-space position.
Return type: vec3
Returns: a position vector describing where this transform will be translated to in its’ parent’s space.

get_right(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-space right vector.
Return type: vec3
Returns: a vector pointing right relative to the current transform placed in its’ parent’s space.

get_rotation(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous rotation.
Return type: quat
Returns: A quaternion rotating the transform from local to parent

get_scale(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous scale.
Return type: vec3
Returns: the scale of this transform from local to parent space along its right, up, and forward directions respectively

get_up(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous parent-space up vector.
Return type: vec3
Returns: a vector pointing up relative to the current transform placed in its’ parent’s space.

get_world_forward(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous world-space forward vector.
Return type: vec3
Returns: a vector pointing forward relative to the current transform placed in world-space.

get_world_position(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous world-space position.
Return type: vec3
Returns: a position vector describing where this transform will be translated to in world-space.

get_world_right(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous world-space right vector.
Return type: vec3
Returns: a vector pointing right relative to the current transform placed in world-space.

get_world_to_local_matrix(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous world-to-local matrix.
Return type: mat4
Returns: a matrix transforming this component from world space to its local space, taking all parent transforms into account.

get_world_up(previous=False)

Parameters: previous (boolean, optional) – If true, returns the previous world-space up vector.
Return type: vec3
Returns: a vector pointing up relative to the current transform placed in world-space.

static initialize_factory(max_components): Allocates the tables used to store all transform components

inverse_transform_direction(direction, previous=False)

Transforms a direction from parent space to local space. The opposite of Transform.transform_direction. This operation is unaffected by scale.

Parameters

point – The direction to apply the inverse transform to.
previous (boolean, optional) – If true, uses the previous transform as the transform to apply.

Return type

vec3

Returns

The transformed direction.

inverse_transform_point(point, previous=False)

Transforms position from parent space to local space. Essentially the opposite of Transform.transform_point. Note, affected by scale.

Parameters

point (vec3) – The point to apply the inverse transform to.
previous (boolean, optional) – If true, uses the previous transform as the transform to apply.

Return type

vec3

Returns

The transformed point.

inverse_transform_vector(vector, previous=False)

Transforms a vector from parent space to local space. The opposite of Transform.transform_vector. This operation is affected by scale.

Parameters

point – The vector to apply the inverse transform to.
previous (boolean, optional) – If true, uses the previous transform as the transform to apply.

Return type

vec3

Returns

The transformed vector.

is_initialized()

Return type: boolean
Returns: True the current transform is a valid, initialized transform, and False if the transform was cleared or removed.

look_at(*args, **kwargs)

Rotates the transform so the forward vector points at the target’s current position. Then it rotates the transform to point its up direction vector in the direction hinted at by the parentUp vector.

Parameters

at (vec3) – The position to point the transform towards
up (vec3) – The unit direction pointing upwards
eye (vec3, optional) – (optional) The position to place the object
previous (boolean, optional) – If true, edits the previous translation and/or rotation.

static remove(name)

Parameters: name (string) – The name of the transform to remove

remove_child(child)

Removes a child transform previously added to the current transform.

Parameters: child (Transform) – The constrained child transform component to un-constrain from the current transform. Any existing parent constraint is replaced.

rotate_around(point, quaternion, previous=False)

Rotates the transform through the provided quaternion, passing through the provided point in parent coordinates. This modifies both the position and rotation of the transform.

Parameters

point (vec3) – The pivot point in space to rotate around.
quaternion (quat) – The quaternion to use for rotation.
previous (boolean, optional) – If true, edits the previous translation and rotation.

set_angle_axis(angle, axis, previous=False)

Sets the rotation of the transform from local to parent using an axis in local space to rotate about, and an angle in radians to drive the rotation.

Parameters

angle (float) – The angle (in radians) to rotate.
axis (vec3) – The axis to rotate about.
previous (boolean, optional) – If true, edits the previous rotation.

set_angular_velocity(velocity, frames_per_second=1.0, mix=0.0)

Sets the angular velocity vector describing how fast this transform is rotating within its parent space. Causes motion blur.

Parameters

velocity (quat) – The new angular velocity to set the current transform angular velocity to, in radians per second.
frames_per_second (float, optional) – Used to convert radians per second into scale per frame. Useful for animations.

set_linear_velocity(velocity, frames_per_second=1.0, mix=0.0)

Sets the linear velocity vector describing how fast this transform is translating within its parent space. Causes motion blur.

Parameters

velocity (vec3) – The new linear velocity to set the current transform linear velocity to, in meters per second.
frames_per_second (float, optional) – Used to convert meters per second into meters per frame. Useful for animations.

set_parent(parent)

Set the parent of this transform, whose transformation will be applied after the current transform.

Parameters: parent (Transform) – The transform component to constrain the current transform to. Any existing parent constraint is replaced.

set_position(newPosition, previous=False)

Sets the position vector describing where this transform should be translated to when placed in its parent space.

Parameters

newPosition (vec3) – The new position to set the current transform position to.
previous (boolean, optional) – If true, edits the previous position.

set_rotation(newRotation, previous=False)

Sets the rotation of the transform from local to parent via a quaternion

Parameters

newRotation (quat) – The new rotation quaternion to set the current transform quaternion to.
previous (boolean, optional) – If true, edits the previous rotation.

set_scalar_velocity(velocity, frames_per_second=1.0, mix=0.0)

Sets the scalar velocity vector describing how fast this transform is scaling within its parent space. Causes motion blur.

Parameters

velocity (vec3) – The new scalar velocity to set the current transform scalar velocity to, in additional scale per second
frames_per_second (float, optional) – Used to convert additional scale per second into additional scale per frame. Useful for animations.

set_scale(newScale, previous=False)

Sets the scale of this transform from local to parent space along its right, up, and forward directions respectively.

Parameters

newScale (vec3) – The new scale to set the current transform scale to.
previous (boolean, optional) – If true, edits the previous scale.

set_transform(transformation, decompose=True, previous=False)

Sets an optional additional transform, useful for representing normally unsupported transformations like sheers and projections.

Parameters

transformation (mat4) – a 4 by 4 column major transformation matrix
decompose (boolean, optional) – attempts to use the technique described in “Graphics Gems II: Decomposing a Matrix Into Simple Transformations” to represent the transform as a user controllable translation, rotation, and scale. If a sheer is detected, or if the decomposition failed, this will fall back to a non-decomposed transformation, and user controllable translation, rotation, and scale will be set to identity values.
previous (boolean, optional) – If true, edits the previous translation, rotation, and scale.

property thisown: The membership flag

to_string()

Return type: string
Returns: a json string representation of the current component

transform_direction(direction, previous=False)

Transforms direction from local to parent. This operation is not affected by scale or position of the transform. The returned vector has the same length as the input direction.

Parameters

direction (vec3) – The direction to apply the transform to.
previous (boolean, optional) – If true, uses the previous transform as the transform to apply.

Return type

vec3

Returns

The transformed direction.

transform_point(point, previous=False)

Transforms position from local to parent. Note, affected by scale. The opposite conversion, from parent to local, can be done with Transform.inverse_transform_point

Parameters

point (vec3) – The point to apply the transform to.
previous (boolean, optional) – If true, uses the previous transform as the transform to apply.

Return type

vec3

Returns

The transformed point.

transform_vector(vector, previous=False)

Transforms vector from local to parent. This is not affected by position of the transform, but is affected by scale. The returned vector may have a different length that the input vector.

Parameters

vector (vec3) – The vector to apply the transform to.
previous (boolean, optional) – If true, uses the previous transform as the transform to apply.

Return type

vec3

Returns

The transformed vector.

nvisii.transform_are_any_dirty()

Return type: boolean
Returns: True if any the transform has been modified since the previous frame, and False otherwise

nvisii.transform_clear_all(): Clears any existing transform components.

nvisii.transform_create(*args, **kwargs)

Constructs a transform with the given name.

Parameters

name (string) – A unique name for this transform.
scale (vec3, optional) – The initial scale of the transform, applied first.
rotation (quat, optional) – The initial scale of the transform, applied after scale.
position (vec3, optional) – The initial position of the transform, applied after rotation.

Return type

Transform

Returns

a reference to a transform component

nvisii.transform_create_from_matrix(*args, **kwargs)

Constructs a transform with the given name, initializing with the given matrix.

Parameters

name (string) – A unique name for this transform.
matrix – The initial local to world transformation to be applied

Return type

Transform

Returns

a reference to a transform component

nvisii.transform_get(name)

Parameters: name (string) – The name of the transform to get
Return type: Transform
Returns: a transform who’s name matches the given name

nvisii.transform_get_count()

Return type: int
Returns: the number of allocated transforms

nvisii.transform_get_dirty_transforms()

Return type: std::set< nvisii::Transform * >
Returns: a list of transforms that have been modified since the previous frame

nvisii.transform_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a transform name and whose value is the ID for that transform

nvisii.transform_initialize_factory(max_components): Allocates the tables used to store all transform components

nvisii.transform_remove(name)

Parameters: name (string) – The name of the transform to remove

nvisii.translate(arg1, arg2) → mat4

arg1: glm::mat4 const & arg2: glm::vec3 const &

translate(arg1) -> mat4

arg1: glm::vec3 const &

nvisii.transpose(arg1) → mat3

arg1: glm::mat3 const &

transpose(arg1) -> mat4

arg1: glm::mat4 const &

nvisii.trunc(arg1) → float

arg1: float const &

trunc(arg1) -> vec2

arg1: glm::vec2 const &

trunc(arg1) -> vec3

arg1: glm::vec3 const &

trunc(arg1) -> vec4

arg1: glm::vec4 const &

nvisii.tweakedInfinitePerspective(arg1, arg2, arg3) → mat4: arg1: float const & arg2: float const & arg3: float const &

nvisii.two_over_pi() → float

nvisii.two_over_root_pi() → float

nvisii.two_thirds() → float

class nvisii.u16vec2(*args)

Proxy of C++ glm::u16vec2 class.

static length() → glm::length_t

property thisown: The membership flag

property x

property y

nvisii.u16vec2_length() → glm::length_t

class nvisii.u16vec3(*args)

Proxy of C++ glm::u16vec3 class.

static length() → glm::length_t

property thisown: The membership flag

property x

property y

property z

nvisii.u16vec3_length() → glm::length_t

class nvisii.u16vec4(*args)

Proxy of C++ glm::u16vec4 class.

static length() → glm::length_t

property thisown: The membership flag

property w

property x

property y

property z

nvisii.u16vec4_length() → glm::length_t

nvisii.unProject(arg1, arg2, arg3, arg4) → vec3: arg1: glm::vec3 const & arg2: glm::mat4 const & arg3: glm::mat4 const & arg4: glm::vec4 const &

class nvisii.vec2(*args)

Proxy of C++ glm::vec2 class.

static length() → glm::length_t

property thisown: The membership flag

property x

property y

nvisii.vec2_length() → glm::length_t

class nvisii.vec3(*args)

Proxy of C++ glm::vec3 class.

static length() → glm::length_t

property thisown: The membership flag

property x

property y

property z

nvisii.vec3_length() → glm::length_t

class nvisii.vec4(*args)

Proxy of C++ glm::vec4 class.

static length() → glm::length_t

property thisown: The membership flag

property w

property x

property y

property z

nvisii.vec4_length() → glm::length_t

class nvisii.volume(*args, **kwargs)

The “Volume” component is essentially the dual of a mesh component. As a result, entities can have a mesh component or a volume component attached, but not both.

With a mesh component, surfaces are explicitly defined using triangles, and the volumes separating that surface are implicit (eg air outside vs glass inside). With a Volume component, that’s reversed. Voxels are used to explicitly represent the density of particles in space, and surfaces are implicitly defined in areas where particles are dense.

static are_any_dirty(): Indicates whether or not any entities are “out of date” and need to be updated through the “update components” function

static clear_all(): Clears any existing Volume components.

static create_box(*args, **kwargs): Creates a sparse fog volume of a box such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the box to 1 at the half width and interior of the box. :type name: string :param name: The name of the volume to create. :type size: vec3, optional :param size: The width, height, and depth of the box in local units. :type center: vec3, optional :param center: The center of the box in local units :type half_width: float, optional :param half_width: The half-width of the narrow band in voxel units

static create_from_data(name, width, height, depth, data, background)

Constructs a Volume with the given name from custom user data. :type name: string :param name: The name of the volume to create. :type width: int :param width: The width of the volume. :type height: int :param height: The height of the volume. :type depth: int :param depth: The depth of the volume. :type data: float :param data: A row major flattened vector of single-scalar voxels.

The length of this vector should be width * height * depth.

Parameters: background (float) – If a voxel matches this value, that voxel is considered as “empty”. This is used to “sparcify” the volume and save memory.

static create_from_file(name, path)

Constructs a Volume with the given name from a file. :type name: string :param name: The name of the volume to create.

Supported formats include NanoVDB (.nvdb)

Parameters: path (string) – The path to the file.
Return type: Volume
Returns: a Volume allocated by the renderer.

static create_octahedron(name): Creates a sparse fog volume of an octahedron such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the octahedron to 1 at the half width and interior of the octahedron

static create_sphere(name): Creates a sparse fog volume of a sphere such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the sphere to 1 at the half width and interior of the sphere.

static create_torus(name): Creates a sparse fog volume of a torus in the xz-plane such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the torus to 1 at the half width and interior of the torus.

static get(name)

Parameters: name (string) – The name of the Volume to get
Return type: Volume
Returns: a Volume who’s name matches the given name

get_aabb_center(level, node_idx)

Parameters

level (int) – The level of nodes being referenced (0->3 = leaf -> root).
node_idx (int) – The index of the node within the selected level.

Return type

vec3

Returns

the center of the aligned bounding box for a node

static get_count()

Return type: int
Returns: the number of allocated volumes

static get_dirty_volumes()

Return type: std::set< nvisii::Volume * >
Returns: a list of volumes that have been modified since the previous frame

static get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing by the renderer.

static get_front()

Return type: Volume
Returns: a pointer to the table of Volume components

static get_front_struct()

Return type: VolumeStruct
Returns: a pointer to the table of VolumeStructs

get_grid_type()

Return type: string
Returns: the type of the volume’s scalar field

get_id()

Return type: int
Returns: the unique integer ID for this component

get_max(level, node_idx): todo… document

get_max_aabb_corner(level, node_idx)

Parameters

level (int) – The level of nodes being referenced (0->3 = leaf -> root).
node_idx (int) – The index of the node within the selected level.

Return type

vec3

Returns

the maximum node axis aligned bounding box position

get_min_aabb_corner(level, node_idx)

Parameters

level (int) – The level of nodes being referenced (0->3 = leaf -> root).
node_idx (int) – The index of the node within the selected level.

Return type

vec3

Returns

the minimum node axis aligned bounding box position

get_name()

Return type: string
Returns: the name of this component

static get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a volume name and whose value is the ID for that volume

get_nano_vdbgrid_handle()

Return type: std::shared_ptr< nanovdb::GridHandle< > >
Returns: the handle to the nanovdb grid. For internal purposes.

get_node_count(level)

Parameters: level (int) – The level of nodes being referenced (0->3 = leaf -> root)
Return type: int
Returns: the number of nodes, or subvolumes, used to store a volume. (See the illustration of the NanoVDB data structure for more details)

static initialize_factory(max_components): Allocates the tables used to store all Volume components

static is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all Volume components have been allocated, and False otherwise

is_initialized()

Return type: boolean
Returns: True the current Volume is a valid, initialized Volume, and False if the Volume was cleared or removed.

mark_dirty(): Tags the current component as being modified since the previous frame.

static remove(name)

Parameters: name (string) – The name of the Volume to remove

set_absorption(absorption): todo… document

set_gradient_factor(factor): todo… document

set_scale(units): todo… document

set_scattering(scattering): todo… document

property thisown: The membership flag

to_string()

Return type: string
Returns: a json string representation of the current component

static update_components(): Iterates through all components, updating any component struct fields and marking components as clean.

nvisii.volume_are_any_dirty(): Indicates whether or not any entities are “out of date” and need to be updated through the “update components” function

nvisii.volume_clear_all(): Clears any existing Volume components.

nvisii.volume_create_box(*args, **kwargs): Creates a sparse fog volume of a box such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the box to 1 at the half width and interior of the box. :type name: string :param name: The name of the volume to create. :type size: vec3, optional :param size: The width, height, and depth of the box in local units. :type center: vec3, optional :param center: The center of the box in local units :type half_width: float, optional :param half_width: The half-width of the narrow band in voxel units

nvisii.volume_create_from_data(name, width, height, depth, data, background)

Constructs a Volume with the given name from custom user data. :type name: string :param name: The name of the volume to create. :type width: int :param width: The width of the volume. :type height: int :param height: The height of the volume. :type depth: int :param depth: The depth of the volume. :type data: float :param data: A row major flattened vector of single-scalar voxels.

The length of this vector should be width * height * depth.

Parameters: background (float) – If a voxel matches this value, that voxel is considered as “empty”. This is used to “sparcify” the volume and save memory.

nvisii.volume_create_from_file(name, path)

Constructs a Volume with the given name from a file. :type name: string :param name: The name of the volume to create.

Supported formats include NanoVDB (.nvdb)

Parameters: path (string) – The path to the file.
Return type: Volume
Returns: a Volume allocated by the renderer.

nvisii.volume_create_octahedron(name): Creates a sparse fog volume of an octahedron such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the octahedron to 1 at the half width and interior of the octahedron

nvisii.volume_create_sphere(name): Creates a sparse fog volume of a sphere such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the sphere to 1 at the half width and interior of the sphere.

nvisii.volume_create_torus(name): Creates a sparse fog volume of a torus in the xz-plane such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the torus to 1 at the half width and interior of the torus.

nvisii.volume_get(name)

Parameters: name (string) – The name of the Volume to get
Return type: Volume
Returns: a Volume who’s name matches the given name

nvisii.volume_get_count()

Return type: int
Returns: the number of allocated volumes

nvisii.volume_get_dirty_volumes()

Return type: std::set< nvisii::Volume * >
Returns: a list of volumes that have been modified since the previous frame

nvisii.volume_get_edit_mutex(): For internal use. Returns the mutex used to lock entities for processing by the renderer.

nvisii.volume_get_front()

Return type: Volume
Returns: a pointer to the table of Volume components

nvisii.volume_get_front_struct()

Return type: VolumeStruct
Returns: a pointer to the table of VolumeStructs

nvisii.volume_get_name_to_id_map()

Return type: std::map< std::string,uint32_t,std::less< std::string >,std::allocator< std::pair< std::string const,uint32_t > > >
Returns: A map whose key is a volume name and whose value is the ID for that volume

nvisii.volume_initialize_factory(max_components): Allocates the tables used to store all Volume components

nvisii.volume_is_factory_initialized()

Return type: boolean
Returns: True if the tables used to store all Volume components have been allocated, and False otherwise

nvisii.volume_remove(name)

Parameters: name (string) – The name of the Volume to remove

nvisii.volume_update_components(): Iterates through all components, updating any component struct fields and marking components as clean.

nvisii.yaw(x) → float: x: glm::quat const &

nvisii.zero() → float