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