cil Namespace Reference

Classes
class	AbstractLocator
	The AbstractLocator class inheriting from Node class and EventWatcher class, representing the abstract locator. More...
class	ArcHandler
	The ArcHandler class inherits from the Handler class, specifically designed for rotating operation. More...
class	ArrayBuffer
class	ArrayIndices
class	ArrowLocator
	This class, inheriting from Locator, is constructed with one line handler, specifically designed for translating geometry along a single line. More...
class	AttributeBuilder
class	AttributeProducer
class	Attributes
class	AttributeSelector
class	AxialTransformPath
class	Axis
class	Background
	The Background class represents the configuration for a background element used in a rendering Pass. More...
class	BaseSelector
class	Blend
	The Blend class inherits from the State class, describing the blending operation during rendering transparent objects. More...
class	Block
class	BottomBoxLocator
	The BottomBoxLocator, inheriting from the BoxLocator, lacks the shape handler for the negative z-axis face, effectively fixing it. More...
class	BottomCylinderLocator
	The BottomCylinderLocator, inheriting from the CylinderLocator, lacks the shape handler for the bottom face, effectively fixing it. More...
class	BoundingBox
	The BoundingBox class inherits from Box3, specilizing the template parameters to float for element type and Vector3f for representing minimum and maximum extents of the box. More...
class	Box
	The Box is a templated class inheriting from the Tuple class，from which we can derive box2 and box3 correspondingly represents a rectangular zone or cubic zone. More...
class	Box2
	The Box2 is a templated class inheriting from the Box class, which represents a rectangular zone. More...
class	Box2f
	The Box2f class inherits from Box2, specilizing the template parameters to float for element type and Vector2f for representing minimum and maximum extents of the box. More...
class	Box2i
	The Box2i class inherits from Box2, specilizing the template parameters to int for element type and Vector2i for representing minimum and maximum extents of the box. More...
class	Box3
	The Box3 is a templated class inheriting from the Box class, which represents a cubic zone. More...
class	Box3f
	The Box3f class inherits from Box3, specilizing the template parameters to float for element type and Vector3f for representing minimum and maximum extents of the box. More...
class	Box3i
	The Box3i class inherits from Box3, specilizing the template parameters to int for element type and Vector3i for representing minimum and maximum extents of the box. More...
class	BoxConsumer
class	BoxLocator
	BoxLocator class, inheriting from the ShapeLocator class, is specifically designed for bounding boxes. It's constructed with a box geometry and includes six shape handlers, one for each face of the box. More...
class	BSplineCurve
class	Camera
class	Clip
class	ClipParameters
class	Clipper
class	Clipping
class	Color
	The Color is a templated class that inherits publicly from a class named Tuple<T>. More...
class	Color3
	The class Color3 is a templated class inheriting from the Color class. A Color3 object holds 3 elements. More...
class	Color3f
	The Color3f class inherits from Color3, specilizing the template parameters to float for element type. More...
class	Color3ub
	The Color3ub class inherits from Color3, specilizing the template parameters to unsigned char for element type. More...
class	Color4
	The class Color4 is a templated class inheriting from the Color class. A Color4 object holds 4 elements. More...
class	Color4f
	The Color4f class inherits from Color4, specilizing the template parameters to float for element type. More...
class	Color4ub
	The Color4ub class inherits from Color4, specilizing the template parameters to unsigned char for element type. More...
class	ColorGenerator
class	ColorIndex
class	ColorMask
	The ColorMask class represents the color channel writing during rendering. More...
class	ColorScheme
class	CompositeLocator
	The CompositeLocator class inheriting from AbstractLocator class, represents a locator composed of two different locator types. These types are typically a position or orientation locator and a shape locator. More...
class	Contour
class	ContourParameters
class	CornerViewCube
class	Culling
	The Culling class inherits from the base class State, describing the culling operation during rendering a 3D object. More...
class	Cutter
class	CutterParameters
class	CylinderLocator
	The CylinderLocator class, inheriting from the ShapeLocator class, is constructed with a cylinder geometry and includes one shape handler on the cylider face and two other shape handlers on the top and bottom faces. More...
class	DataModel
class	DataObject
class	DataPart
class	DataScalarMap
class	DataSet
class	DataSolution
class	DataVectorMap
class	Decal
class	Decals
class	Depth
	The Depth class inherits from the base class State, describing how the depth test is operated during rendering. More...
class	DiskLocator
	This class, inheriting from the PlaneLocator, adds an arc handler to the parent class, enabling rotation around z axis. More...
class	EdgeBuilder
class	EdgeProducer
class	EdgeSelector
class	ElementIndices
	The ElementIndices class represents a indices buffer, which is a block of memory that stores the index data of a Geometry. More...
class	EntityBuilder
class	EntityProducer
class	EntitySelector
class	Exploder
class	FaceBuilder
class	FaceProducer
class	FaceSelector
class	Filter
class	FilterAttributes
class	FitBSplineCurve
class	Float32Array
class	Float64Array
class	Font
class	FontEngine
class	FragmentSource
class	FringeSurface
class	FringeSurfaceParameters
class	FullViewCube
class	Geometry
	The Geometry class is a collection of geometric data. More...
class	GeometrySource
class	Glyph
class	Handler
	The Handler class, inheriting from Node, represents a draggable element within a Locator object. Users can click upon the handler and drag it to a new location. More...
class	Hsl
class	Hsv
class	Image
	The Image class inherits from the TypedArray class, specilizing the template parameter to unsigned char. More...
class	Image2D
class	ImageBuffer
class	ImageCube
class	ImageDecal
class	Indices
	The Indices class represents the connecting relationship between vertices. More...
class	Int16Array
class	Int32Array
class	Int8Array
class	Integer
	The Integer class inherits from the Tuple class and stores a single integer. More...
class	Legend
class	LegendPass
class	Lego
class	Line
	The Line class inherits from the base class State, defining width of Line. More...
class	LineHandler
	The LineHandler class inherits from the Handler class, specifically designed for translating operation. More...
class	Loader
class	Locator
	The Locator class defines . It has specialized subclasses with methods for interacting with specific Handler objects. More...
class	LocatorColorParameters
class	LocatorGeometryParameters
class	LocatorPass
	The LocatorPass class inheriting from EventWatcher class and Pass class, representing a rendering pass specifically for Locator objects. More...
class	Material
	The Material class defines the material properties of an object. It affects the appearance of the object during rendering. More...
class	Matrix
	The templated class Matrix inherits from the templated class Tuple which is being instantiated with a specified data type of float. More...
class	Matrix2f
	The Matrix2f class is 2 X 2 matrix. More...
class	Matrix3f
	The Matrix3f class is 3 X 3 matrix. More...
class	Matrix4f
	The Matrix4f class is 4 X 4 matrix. More...
class	Mesh
	The Mesh class represents a 3D mesh, which is a collection of geometric primitives that together define the shape of an object. More...
class	MiniViewCube
class	MinMax
	The MinMax class inherits from Tuple, specilizing the template parameters to float for element type. More...
class	MouseAction
class	MouseClickedAction
class	MouseDraggedAction
class	MouseHeldAction
class	MouseHoveredAction
class	MouseManipulator
class	MouseWheeledAction
class	NavigationManipulator
class	Node
	The Node class represents a node in a scene graph. A scene graph is a hierarchicaldata stucture used to organize and manage 3D objects in a scene. More...
class	NormalBuilder
class	NormalProducer
class	NormalSelector
class	Object
class	OrbitAction
class	OrientationLocator
	This class inherits from the PositionLocator class and it adds three perpendicular arc handlers on the basis of the parent class, enabling rotation around three different direction. More...
class	PanAction
class	Parameters
class	PartAttributes
class	Pass
	The Pass class represents a rendering pass within a graphics pipeline. More...
class	PassThroughEdgeSelector
class	PassThroughEntitySelector
class	PassThroughFaceSelector
class	PassThroughVertexSelector
class	PixelConsumer
class	Plane
	The Plane class inherits from the Tuple class, specilizing the templated parameter to float for element type. More...
class	PlaneClipping
class	PlaneLocator
	This class, inheriting from Locator, is constructed with two line handlers, specifically designed for translation along x and y direction. More...
class	Point
	The Point class inherits from the base class State, defining size and other properties of Point. More...
class	PointCloud
class	PointCloudParameters
class	PointParameters
class	Polygon
	The Polygon class inherits from the base class State, defining mode of Polygon. More...
class	PolygonOffset
	The PolygonOffset class inherits from the base class State, defining the polygon offset. More...
class	PolygonSurface
class	PolygonSurfaceParameters
class	PositionBuilder
class	PositionLocator
	This class, inheriting from Locator, is constructed with three perpendicular line handlers, specifically designed for translating geometry along these three lines. More...
class	PositionProducer
class	PositionSelector
class	Primitive
	The Primitive class represents a basic building block for rendering 3D objects. More...
class	PrimitiveBuilder
class	PrimitiveProducer
class	PrimitiveSelector
class	Probe
class	Program
	The Program class represents a shader program containing vertex and fragment shaders used for rendering with specific material properties. More...
class	Quaternion
	The Quaternion class inherits from the Tuple class, specilizing the templated parameter to float for element type. More...
class	Query
class	RadialTransformPath
class	Ray
	The Ray class inherits from the Tuple class, specilizing the templated parameter to float for element type. More...
class	Real
	The Real class inherits from the Tuple class and stores a single float. More...
class	RenderContext
	The RenderContext Class provides a set of interfaces for managing the lifycycle and state of an OpenGL rendering context. More...
class	Renderer
	The Renderer class provides a comprehensive set of interfaces for managing and rendering scene. More...
class	Rgb
class	Ribbon
class	RibbonParameters
class	RollAction
class	Sampler
	The Sampler class specifies the texture pixel mapping and wrapping mode to a large object. More...
class	Scale
class	Scenario
class	ScenarioSettings
class	Scene
	The Scene class represents a complete 3D scene. More...
class	Scissor
	The Scissor class inherits from the base class State, defining a scissor test that discards fragments that fall outside of a certain rectangular portion of the screen. More...
class	SelectionBuilder
class	SelectionConsumer
class	SelectionProducer
class	Selector
class	SelectorEngine
class	SelectorOptions
class	ShapeHandler
	The ShapeHandler class inherits from the Handler class, specifically designed for scaling operation. More...
class	ShapeLocator
	The ShapeLocator class, inheriting from the Locator class, is specifically designed for determining the geometric extent in geometry scaling operation. More...
class	Slice
class	SliceParameters
class	Source
	The Source class inherits from the Variant, representing the OpenGl Shading Language. More...
class	SpaceMouseManipulator
class	SpaceTransformPath
class	SphereClipping
class	SphereLocator
	The SphereLocator class, inheriting from the ShapeLocator class, is constructed with a sphere geometry and includes one shape handler on the sphere face. More...
class	State
	The State class is a basic class representing the rendering state setting. More...
class	Stencil
	The Stencil class inherits from the base class State, describing how the stencil test is operated during rendering. More...
class	StreamSurface
class	StreamSurfaceParameters
class	StreamTracer
class	StreamTracerParameters
class	Target
class	TextDecal
class	Texture
	The Texture class defines the texture image and sampling behaviour when you need to map a texture to an object. More...
class	Threshold
class	ThresholdParameters
class	Timer
class	TouchManipulator
class	TransformPath
class	Tube
class	TubeParameters
class	Tuple
	The Tuple is a templated class inheriting from the most basic class Variant. More...
class	TwoPlaneClipping
class	TypedArray
class	Uint16Array
class	Uint32Array
class	Uint8Array
class	Variant
	The Variant class is the most basic class of other mathamatic classes. More...
class	Vector
	The Vector is a templated class inheriting from the Tuple class, and it can store a pecific number of elements of a certain data type. More...
class	Vector2
	The class Vector2 is a templated class inheriting from the Vector class. A vector2 object holds 2 elements. More...
class	Vector2f
	The class Vector2f inherits from the templated class of Vector2, and the template parameters are specified. Each element in the Vector2f object will be a float. More...
class	Vector2i
	The class Vector2i inherits from the templated class of Vector2, and the template parameters are specified. Each element in the Vector2i object will be an integer. More...
class	Vector3
	The class Vector3 is a templated class inheriting from the Vector class. A vector3 object holds 3 elements. More...
class	Vector3f
	The class Vector3f inherits from the templated class of Vector3, and the template parameters are specified. Each element in the Vector3f object will be a float. More...
class	Vector3i
	The class Vector3i inherits from the templated class of Vector3, and the template parameters are specified. Each element in the Vector3i object will be an integer. More...
class	Vector4
	The class Vector4 is a templated class inheriting from the Vector class. A vector4 object holds 4 elements. More...
class	Vector4f
	The class Vector4f inherits from the templated class of Vector4, and the template parameters are specified. Each element in the Vector4f object will be a float. More...
class	Vector4i
	The class Vector4i inherits from the templated class of Vector4, and the template parameters are specified. Each element in the Vector4i object will be an integer. More...
class	Version
class	VertexBuilder
class	VertexProducer
class	VertexSelector
class	VertexSource
class	Vertices
	The Vertices class represents a vertex buffer, which is a block of memory on the GPU that stores vertex attributes data for rendering. More...
class	ViewCube
struct	ViewSpec
	Define a structure objec ViewSpec consisting of four member variables, which correspond to 3D vectors representing the right, up, direction and eye position of the view. More...
class	VizBody
class	VizGeometry
class	VizModel
class	VizPart
class	VizResult
class	VizScalar
class	VizSolution
class	VizVector
class	Yuv
class	ZoomAction

Typedefs
using	BackgroundPtr = std::shared_ptr<Background>
using	GeometryPtr = std::shared_ptr<Geometry>
using	IndicesPtr = std::shared_ptr<Indices>
using	ArrayIndicesPtr = std::shared_ptr<ArrayIndices>
using	ElementIndicesPtr = std::shared_ptr<ElementIndices>
using	MaterialPtr = std::shared_ptr<Material>
using	PrimitivePtr = std::shared_ptr<Primitive>
using	ProgramPtr = std::shared_ptr<Program>
using	QueryPtr = std::shared_ptr<Query>
using	SamplerPtr = std::shared_ptr<Sampler>
using	StatePtr = std::shared_ptr<State>
using	BlendPtr = std::shared_ptr<Blend>
using	ColorMaskPtr = std::shared_ptr<ColorMask>
using	CullingPtr = std::shared_ptr<Culling>
using	DepthPtr = std::shared_ptr<Depth>
using	LinePtr = std::shared_ptr<Line>
using	PointPtr = std::shared_ptr<Point>
using	PolygonPtr = std::shared_ptr<Polygon>
using	PolygonOffsetPtr = std::shared_ptr<PolygonOffset>
using	ScissorPtr = std::shared_ptr<Scissor>
using	StencilPtr = std::shared_ptr<Stencil>
using	TexturePtr = std::shared_ptr<Texture>
using	TargetPtr = std::shared_ptr<Target>
using	VerticesPtr = std::shared_ptr<Vertices>
using	CameraPtr = std::shared_ptr<Camera>
using	MeshPtr = std::shared_ptr<Mesh>
using	NodePtr = std::shared_ptr<Node>
using	PassPtr = std::shared_ptr<Pass>
using	ScenePtr = std::shared_ptr<Scene>
using	box2 = Box2f
using	ibox2 = Box2i
using	box3 = Box3f
using	ibox3 = Box3i
using	bbox = BoundingBox
using	clr3 = Color3f
using	clr3ub = Color3ub
using	clr4 = Color4f
using	clr4ub = Color4ub
using	image2d = Image2D
using	imageCube = ImageCube
using	imageBuf = ImageBuffer
using	integer = Integer
using	mat2 = Matrix2f
using	mat3 = Matrix3f
using	mat4 = Matrix4f
using	minmax = MinMax
using	plane = Plane
using	quat = Quaternion
using	ray = Ray
using	real = Real
using	vert = VertexSource
using	frag = FragmentSource
using	geom = GeometrySource
using	i8array = Int8Array
using	u8array = Uint8Array
using	i16array = Int16Array
using	u16array = Uint16Array
using	i32array = Int32Array
using	u32array = Uint32Array
using	f32array = Float32Array
using	f64array = Float64Array
using	Box2fPtr = std::shared_ptr<Box2f>
using	Box2iPtr = std::shared_ptr<Box2i>
using	Box3fPtr = std::shared_ptr<Box3f>
using	Box3iPtr = std::shared_ptr<Box3i>
using	BoundingBoxPtr = std::shared_ptr<BoundingBox>
using	Color3fPtr = std::shared_ptr<Color3f>
using	Color3ubPtr = std::shared_ptr<Color3ub>
using	Color4fPtr = std::shared_ptr<Color4f>
using	Color4ubPtr = std::shared_ptr<Color4ub>
using	ImagePtr = std::shared_ptr<Image>
using	Image2DPtr = std::shared_ptr<Image2D>
using	ImageCubePtr = std::shared_ptr<ImageCube>
using	ImageBufferPtr = std::shared_ptr<ImageBuffer>
using	IntegerPtr = std::shared_ptr<Integer>
using	Matrix2fPtr = std::shared_ptr<Matrix2f>
using	Matrix3fPtr = std::shared_ptr<Matrix3f>
using	Matrix4fPtr = std::shared_ptr<Matrix4f>
using	MinMaxPtr = std::shared_ptr<MinMax>
using	PlanePtr = std::shared_ptr<Plane>
using	QuaternionPtr = std::shared_ptr<Quaternion>
using	RayPtr = std::shared_ptr<Ray>
using	RealPtr = std::shared_ptr<Real>
using	SourcePtr = std::shared_ptr<Source>
using	VertexSourcePtr = std::shared_ptr<VertexSource>
using	FragmentSourcePtr = std::shared_ptr<FragmentSource>
using	GeometrySourcePtr = std::shared_ptr<GeometrySource>
using	ArrayBufferPtr = std::shared_ptr<ArrayBuffer>
using	Int8ArrayPtr = std::shared_ptr<Int8Array>
using	Uint8ArrayPtr = std::shared_ptr<Uint8Array>
using	Int16ArrayPtr = std::shared_ptr<Int16Array>
using	Uint16ArrayPtr = std::shared_ptr<Uint16Array>
using	Int32ArrayPtr = std::shared_ptr<Int32Array>
using	Uint32ArrayPtr = std::shared_ptr<Uint32Array>
using	Float32ArrayPtr = std::shared_ptr<Float32Array>
using	Float64ArrayPtr = std::shared_ptr<Float64Array>
using	VariantPtr = std::shared_ptr<Variant>
using	Vector2fPtr = std::shared_ptr<Vector2f>
using	Vector3fPtr = std::shared_ptr<Vector3f>
using	Vector4fPtr = std::shared_ptr<Vector4f>
using	Vector2iPtr = std::shared_ptr<Vector2i>
using	Vector3iPtr = std::shared_ptr<Vector3i>
using	Vector4iPtr = std::shared_ptr<Vector4i>
using	vec2 = Vector2f
using	ivec2 = Vector2i
using	vec3 = Vector3f
using	ivec3 = Vector3i
using	vec4 = Vector4f
using	ivec4 = Vector4i
using	FilterFunction = std::function<std::shared_ptr<Pass>(const std::shared_ptr<Pass>&)>
using	DataScalar = MinMax
using	DataVector = MinMax
using	DataPartPtr = std::shared_ptr<DataPart>
using	DataPartPtrArray = std::vector<DataPartPtr>
using	DataModelPtr = std::shared_ptr<DataModel>
using	DataModelPtrArray = std::vector<DataModelPtr>
using	DataSolutionPtr = std::shared_ptr<DataSolution>
typedef std::function< void(Attributes &, int, int)>	AttributesOverwriter
typedef std::shared_ptr< AttributesOverwriter >	AttributesOverwriterPtr
using	FilterPtr = std::shared_ptr<Filter>
using	FilterPtrArray = std::vector<FilterPtr>
using	FringeSurfacePtr = std::shared_ptr<FringeSurface>
using	PolygonSurfacePtr = std::shared_ptr<PolygonSurface>
using	SlicePtr = std::shared_ptr<Slice>
using	ClipPtr = std::shared_ptr<Clip>
using	ContourPtr = std::shared_ptr<Contour>
using	ThresholdPtr = std::shared_ptr<Threshold>
using	CutterPtr = std::shared_ptr<Cutter>
using	StreamTracerPtr = std::shared_ptr<StreamTracer>
using	StreamSurfacePtr = std::shared_ptr<StreamSurface>
using	TubePtr = std::shared_ptr<Tube>
using	RibbonPtr = std::shared_ptr<Ribbon>
using	ProbePtr = std::shared_ptr<Probe>
using	LegoPtr = std::shared_ptr<Lego>
using	PointCloudPtr = std::shared_ptr<PointCloud>
using	VizScalarPtr = std::shared_ptr<VizScalar>
using	VizScalarPtrMap = std::map<std::string, VizScalarPtr>
using	VizVectorPtr = std::shared_ptr<VizVector>
using	VizVectorPtrMap = std::map<std::string, VizVectorPtr>
using	VizGeometryPtr = std::shared_ptr<VizGeometry>
using	VizResultPtr = std::shared_ptr<VizResult>
using	VizBodyPtr = std::shared_ptr<VizBody>
using	VizBodyPtrArray = std::vector<VizBodyPtr>
using	VizPartPtr = std::shared_ptr<VizPart>
using	VizPartPtrMap = std::map<int, VizPartPtr>
using	VizModelPtr = std::shared_ptr<VizModel>
using	VizModelPtrMap = std::map<int, VizModelPtr>
using	VizSolutionPtr = std::shared_ptr<VizSolution>

Enumerations
enum class	LineStyle {   Solid , Dash , Dot , DashDot ,   DashDotDot }
enum class	SelectorUpdateMode { None , View , Entity , All }

Functions
std::shared_ptr< Decals >	_decals ()
std::shared_ptr< ImageDecal >	_imageDecal (const std::shared_ptr< Image2D > &image, const Vector3f &position)
std::shared_ptr< TextDecal >	_textDecal (const std::wstring &text, const Vector3f &position)
std::shared_ptr< TextDecal >	_textDecal (const std::string &text, const Vector3f &position)
std::shared_ptr< Geometry >	_geometry_decal ()
std::shared_ptr< Geometry >	_geometry_decalBackground ()
std::shared_ptr< Material >	_material_opaqueImage ()
std::shared_ptr< Material >	_material_transparentImage ()
std::shared_ptr< Material >	_material_opaqueText ()
std::shared_ptr< Material >	_material_transparentText ()
std::shared_ptr< Material >	_material_opaqueBackground ()
std::shared_ptr< Material >	_material_transparentBackground ()
std::shared_ptr< Sampler >	_sampler_decal ()
std::shared_ptr< Camera >	crop (const std::shared_ptr< Camera > &camera, const Vector2i &backgroundSize, const Vector2i &point)
std::shared_ptr< Camera >	crop (const std::shared_ptr< Camera > &camera, const Vector2i &backgroundSize, const Box2i &box)
std::shared_ptr< Camera >	crop (const std::shared_ptr< Camera > &camera, const Vector2i &backgroundSize, const Vector2i &topLeft, const Vector2i &size)
Ray	findRay (const std::shared_ptr< Camera > &camera, const Vector2i &point, const Vector2i &windowSize)
void	align (const std::shared_ptr< Camera > &camera, const std::shared_ptr< BoundingBox > &boundingBox, const Vector3f &dir)
void	align (const std::shared_ptr< Camera > &camera, const std::shared_ptr< BoundingBox > &boundingBox, const Vector3f &dir, const const Vector3f &point)
void	center (const std::shared_ptr< Camera > &camera, const Vector3f &point)
void	fit (const std::shared_ptr< Camera > &camera, const BoundingBox &boundingBox, const Vector2i &backgroundSize)
void	home (const std::shared_ptr< Camera > &camera, const BoundingBox &boundingBox)
void	home (const std::shared_ptr< Camera > &camera, const BoundingBox &boundingBox, const Vector2i &backgroundSize)
void	look (const std::shared_ptr< Camera > &camera, const BoundingBox &boundingBox, const std::string &dir)
void	orbit (const std::shared_ptr< Camera > &camera, const Quaternion &rot)
void	orbit (const std::shared_ptr< Camera > &camera, const Quaternion &rot, const Vector3f &center)
void	pan (const std::shared_ptr< Camera > &camera, const Vector2f &offset)
void	project (const std::shared_ptr< Camera > &camera, const BoundingBox &boundingBox, const Vector2i &backgroundSize)
void	roll (const std::shared_ptr< Camera > &camera, const float angle)
void	zoom (const std::shared_ptr< Camera > &camera, const float factor)
void	zoom (const std::shared_ptr< Camera > &camera, const float factor, const Vector3f &offset)
void	resize (const std::shared_ptr< Camera > &camera, const Vector2i &windowSize)
std::shared_ptr< ColorGenerator >	_colorGenerator (float hue=0)
Rgb	toRgb (const Color3f &color)
Rgb	toRgb (const Color4f &color)
Hsv	toHsv (const Color3f &color)
Hsv	toHsv (const Color4f &color)
Hsl	toHsl (const Color3f &color)
Hsl	toHsl (const Color4f &color)
Yuv	toYuv (const Color3f &color)
Yuv	toYuv (const Color4f &color)
std::string	toHex (const Color3f &color)
std::string	toHex (const Color4f &color)
Color3f	fromRgb (const Rgb &rgb)
Color3f	fromHsv (const Hsv &hsv)
Color3f	fromHsl (const Hsl &hsl)
Color3f	fromYuv (const Yuv &yuv)
Color3f	fromHex (const std::string &hex)
std::shared_ptr< Color3f >	_aliceblue ()
std::shared_ptr< Color3f >	_antiquewhite ()
std::shared_ptr< Color3f >	_aqua ()
std::shared_ptr< Color3f >	_aquamarine ()
std::shared_ptr< Color3f >	_azure ()
std::shared_ptr< Color3f >	_beige ()
std::shared_ptr< Color3f >	_bisque ()
std::shared_ptr< Color3f >	_black ()
std::shared_ptr< Color3f >	_blanchedalmond ()
std::shared_ptr< Color3f >	_blue ()
std::shared_ptr< Color3f >	_blueviolet ()
std::shared_ptr< Color3f >	_brown ()
std::shared_ptr< Color3f >	_burlywood ()
std::shared_ptr< Color3f >	_cadetblue ()
std::shared_ptr< Color3f >	_chartreuse ()
std::shared_ptr< Color3f >	_chocolate ()
std::shared_ptr< Color3f >	_coral ()
std::shared_ptr< Color3f >	_cornflowerblue ()
std::shared_ptr< Color3f >	_cornsilk ()
std::shared_ptr< Color3f >	_crimson ()
std::shared_ptr< Color3f >	_cyan ()
std::shared_ptr< Color3f >	_darkblue ()
std::shared_ptr< Color3f >	_darkcyan ()
std::shared_ptr< Color3f >	_darkgoldenrod ()
std::shared_ptr< Color3f >	_darkgray ()
std::shared_ptr< Color3f >	_darkgreen ()
std::shared_ptr< Color3f >	_darkgrey ()
std::shared_ptr< Color3f >	_darkkhaki ()
std::shared_ptr< Color3f >	_darkmagenta ()
std::shared_ptr< Color3f >	_darkolivegreen ()
std::shared_ptr< Color3f >	_darkorange ()
std::shared_ptr< Color3f >	_darkorchid ()
std::shared_ptr< Color3f >	_darkred ()
std::shared_ptr< Color3f >	_darksalmon ()
std::shared_ptr< Color3f >	_darkseagreen ()
std::shared_ptr< Color3f >	_darkslateblue ()
std::shared_ptr< Color3f >	_darkslategray ()
std::shared_ptr< Color3f >	_darkslategrey ()
std::shared_ptr< Color3f >	_darkturquoise ()
std::shared_ptr< Color3f >	_darkviolet ()
std::shared_ptr< Color3f >	_deeppink ()
std::shared_ptr< Color3f >	_deepskyblue ()
std::shared_ptr< Color3f >	_dimgray ()
std::shared_ptr< Color3f >	_dimgrey ()
std::shared_ptr< Color3f >	_dodgerblue ()
std::shared_ptr< Color3f >	_firebrick ()
std::shared_ptr< Color3f >	_floralwhite ()
std::shared_ptr< Color3f >	_forestgreen ()
std::shared_ptr< Color3f >	_fuchsia ()
std::shared_ptr< Color3f >	_gainsboro ()
std::shared_ptr< Color3f >	_ghostwhite ()
std::shared_ptr< Color3f >	_gold ()
std::shared_ptr< Color3f >	_goldenrod ()
std::shared_ptr< Color3f >	_gray ()
std::shared_ptr< Color3f >	_green ()
std::shared_ptr< Color3f >	_greenyellow ()
std::shared_ptr< Color3f >	_grey ()
std::shared_ptr< Color3f >	_honeydew ()
std::shared_ptr< Color3f >	_hotpink ()
std::shared_ptr< Color3f >	_indianred ()
std::shared_ptr< Color3f >	_indigo ()
std::shared_ptr< Color3f >	_ivory ()
std::shared_ptr< Color3f >	_khaki ()
std::shared_ptr< Color3f >	_lavender ()
std::shared_ptr< Color3f >	_lavenderblush ()
std::shared_ptr< Color3f >	_lawngreen ()
std::shared_ptr< Color3f >	_lemonchiffon ()
std::shared_ptr< Color3f >	_lightblue ()
std::shared_ptr< Color3f >	_lightcoral ()
std::shared_ptr< Color3f >	_lightcyan ()
std::shared_ptr< Color3f >	_lightgoldenrodyellow ()
std::shared_ptr< Color3f >	_lightgray ()
std::shared_ptr< Color3f >	_lightgreen ()
std::shared_ptr< Color3f >	_lightgrey ()
std::shared_ptr< Color3f >	_lightpink ()
std::shared_ptr< Color3f >	_lightsalmon ()
std::shared_ptr< Color3f >	_lightseagreen ()
std::shared_ptr< Color3f >	_lightskyblue ()
std::shared_ptr< Color3f >	_lightslategray ()
std::shared_ptr< Color3f >	_lightslategrey ()
std::shared_ptr< Color3f >	_lightsteelblue ()
std::shared_ptr< Color3f >	_lightyellow ()
std::shared_ptr< Color3f >	_lime ()
std::shared_ptr< Color3f >	_limegreen ()
std::shared_ptr< Color3f >	_linen ()
std::shared_ptr< Color3f >	_magenta ()
std::shared_ptr< Color3f >	_maroon ()
std::shared_ptr< Color3f >	_mediumaquamarine ()
std::shared_ptr< Color3f >	_mediumblue ()
std::shared_ptr< Color3f >	_mediumorchid ()
std::shared_ptr< Color3f >	_mediumpurple ()
std::shared_ptr< Color3f >	_mediumseagreen ()
std::shared_ptr< Color3f >	_mediumslateblue ()
std::shared_ptr< Color3f >	_mediumspringgreen ()
std::shared_ptr< Color3f >	_mediumturquoise ()
std::shared_ptr< Color3f >	_mediumvioletred ()
std::shared_ptr< Color3f >	_midnightblue ()
std::shared_ptr< Color3f >	_mintcream ()
std::shared_ptr< Color3f >	_mistyrose ()
std::shared_ptr< Color3f >	_moccasin ()
std::shared_ptr< Color3f >	_navajowhite ()
std::shared_ptr< Color3f >	_navy ()
std::shared_ptr< Color3f >	_oldlace ()
std::shared_ptr< Color3f >	_olive ()
std::shared_ptr< Color3f >	_olivedrab ()
std::shared_ptr< Color3f >	_orange ()
std::shared_ptr< Color3f >	_orangered ()
std::shared_ptr< Color3f >	_orchid ()
std::shared_ptr< Color3f >	_palegoldenrod ()
std::shared_ptr< Color3f >	_palegreen ()
std::shared_ptr< Color3f >	_paleturquoise ()
std::shared_ptr< Color3f >	_palevioletred ()
std::shared_ptr< Color3f >	_papayawhip ()
std::shared_ptr< Color3f >	_peachpuff ()
std::shared_ptr< Color3f >	_peru ()
std::shared_ptr< Color3f >	_pink ()
std::shared_ptr< Color3f >	_plum ()
std::shared_ptr< Color3f >	_powderblue ()
std::shared_ptr< Color3f >	_purple ()
std::shared_ptr< Color3f >	_red ()
std::shared_ptr< Color3f >	_rosybrown ()
std::shared_ptr< Color3f >	_royalblue ()
std::shared_ptr< Color3f >	_saddlebrown ()
std::shared_ptr< Color3f >	_salmon ()
std::shared_ptr< Color3f >	_sandybrown ()
std::shared_ptr< Color3f >	_seagreen ()
std::shared_ptr< Color3f >	_seashell ()
std::shared_ptr< Color3f >	_sienna ()
std::shared_ptr< Color3f >	_silver ()
std::shared_ptr< Color3f >	_skyblue ()
std::shared_ptr< Color3f >	_slateblue ()
std::shared_ptr< Color3f >	_slategray ()
std::shared_ptr< Color3f >	_slategrey ()
std::shared_ptr< Color3f >	_snow ()
std::shared_ptr< Color3f >	_springgreen ()
std::shared_ptr< Color3f >	_steelblue ()
std::shared_ptr< Color3f >	_tan ()
std::shared_ptr< Color3f >	_teal ()
std::shared_ptr< Color3f >	_thistle ()
std::shared_ptr< Color3f >	_tomato ()
std::shared_ptr< Color3f >	_turquoise ()
std::shared_ptr< Color3f >	_violet ()
std::shared_ptr< Color3f >	_wheat ()
std::shared_ptr< Color3f >	_white ()
std::shared_ptr< Color3f >	_whitesmoke ()
std::shared_ptr< Color3f >	_yellow ()
std::shared_ptr< Color3f >	_yellowgreen ()
std::shared_ptr< Image2D >	_image2d_scheme (const ColorScheme &scheme=ColorScheme::rainbow(), int nLevels=256)
std::shared_ptr< Image2D >	_image2d_rainbow ()
std::shared_ptr< Image2D >	_image2d_reverted_rainbow ()
std::shared_ptr< Image2D >	_image2d_black_white ()
std::shared_ptr< Image2D >	_image2d_cool_warm ()
std::shared_ptr< Image2D >	_image2d_metal_casting ()
std::shared_ptr< Image2D >	_image2d_thermal ()
std::shared_ptr< Image2D >	_image2d_viridis ()
std::shared_ptr< Image2D >	_image2d_kindlmann ()
std::shared_ptr< Image2D >	_image2d_inferno ()
std::shared_ptr< Image2D >	_image2d_plasma ()
std::shared_ptr< Image2D >	_image2d_radiation ()
std::shared_ptr< Image2D >	_image2d_green_brown ()
std::shared_ptr< Image2D >	_image2d_white_brown ()
std::shared_ptr< Image2D >	_image2d_gray_red ()
std::shared_ptr< Image2D >	_image2d_jet ()
std::shared_ptr< Image2D >	_image2d_terrain ()
ArrayIndicesPtr	_arrayIndices (Indices::Mode mode, int count, int first=0, int primCount=0)
ArrayIndicesPtr	_triangles (int count, int first=0, int primCount=0)
ArrayIndicesPtr	_triangle_fan (int count, int first=0, int primCount=0)
ArrayIndicesPtr	_triangle_strip (int count, int first=0, int primCount=0)
ArrayIndicesPtr	_lines (int count, int first=0, int primCount=0)
ArrayIndicesPtr	_line_strip (int count, int first=0, int primCount=0)
ArrayIndicesPtr	_line_loop (int count, int first=0, int primCount=0)
ArrayIndicesPtr	_points (int count, int first=0, int primCount=0)
ElementIndicesPtr	_elementIndices (Indices::Mode mode, const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_elementIndices (Indices::Mode mode, const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_elementIndices (Indices::Mode mode, const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangles (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangles (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangles (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangles (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_fan (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_fan (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_fan (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_fan (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_strip (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_strip (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_strip (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_triangle_strip (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_lines (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_lines (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_lines (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_lines (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_strip (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_strip (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_strip (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_strip (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_loop (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_loop (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_loop (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_line_loop (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_points (const Uint8ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_points (const Uint16ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_points (const Uint32ArrayPtr &buffer, int count=-1, int offset=0, int primCount=0)
ElementIndicesPtr	_points (const std::initializer_list< unsigned int > &array, int count=-1, int offset=0, int primCount=0)
VerticesPtr	_vertices (const Float32ArrayPtr &buffer, int offset=0, unsigned int stride=0, unsigned int divisor=0)
VerticesPtr	_vertices (const Int32ArrayPtr &buffer, int offset=0, unsigned int stride=0, unsigned int divisor=0)
VerticesPtr	_vertices (const std::initializer_list< float > &array, int offset=0, unsigned int stride=0, unsigned int divisor=0)
std::shared_ptr< std::map< std::string, VerticesPtr > >	_verticesSet (const std::map< std::string, VerticesPtr > &verticesMap={})
GeometryPtr	_geometry (const std::shared_ptr< std::map< std::string, VerticesPtr > > &verticesSet=_verticesSet(), const IndicesPtr &indices=nullptr, const BoundingBoxPtr &boundingBox=nullptr)
GeometryPtr	_geometry (std::map< std::string, VerticesPtr > verticesSet, const IndicesPtr &indices=nullptr, const BoundingBoxPtr &boundingBox=nullptr)
GeometryPtr	_geometry (const IndicesPtr &indices, const BoundingBoxPtr &boundingBox=nullptr)
BlendPtr	_blend (bool enabled=false, Blend::Function srcFunc=Blend::Function::SRC_ALPHA, Blend::Function dstFunc=Blend::Function::ONE_MINUS_SRC_ALPHA, Blend::Equation equation=Blend::Equation::FUNC_ADD)
ColorMaskPtr	_colorMask (bool red=true, bool green=true, bool blue=true, bool alpha=true)
CullingPtr	_culling (bool enabled=false, Culling::Face face=Culling::Face::CCW, Culling::Mode mode=Culling::Mode::BACK)
DepthPtr	_depth (bool enabled=false, Depth::Function func=Depth::Function::LESS, bool writeMask=true)
LinePtr	_line (float width=1.0f)
PointPtr	_point (float size=1.0f, bool programmable=false)
PolygonPtr	_polygon (Polygon::Mode mode=Polygon::Mode::FILL)
PolygonOffsetPtr	_polygonOffset (bool enabled=false, float factor=0.0f, float units=0.0f)
ScissorPtr	_scissor (bool enabled=false, int x=0, int y=0, int width=0, int height=0)
StencilPtr	_stencil (bool enabled=false, Stencil::Operation sfail=Stencil::Operation::KEEP, Stencil::Operation dpfail=Stencil::Operation::KEEP, Stencil::Operation dppass=Stencil::Operation::KEEP, Stencil::Function func=Stencil::Function::ALWAYS, int ref=0, int mask=0xFF)
SamplerPtr	_sampler (Sampler::Filter minFilter=Sampler::Filter::LINEAR_MIPMAP_NEAREST, Sampler::Filter magFilter=Sampler::Filter::LINEAR, Sampler::WrapMode wrapS=Sampler::WrapMode::REPEAT, Sampler::WrapMode wrapT=Sampler::WrapMode::REPEAT)
SamplerPtr	_samplerClamp ()
SamplerPtr	_samplerRepeat ()
SamplerPtr	_samplerMirror ()
SamplerPtr	_samplerCube ()
TexturePtr	_texture (int unit, const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture0 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture1 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture2 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture3 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture4 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture5 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture6 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
TexturePtr	_texture7 (const ImagePtr &image, const SamplerPtr &sampler=nullptr)
ProgramPtr	_program (const VertexSourcePtr &vertex=nullptr, const FragmentSourcePtr &fragment=nullptr, const GeometrySourcePtr &geometry=nullptr)
ProgramPtr	_program (const FragmentSourcePtr &fragment, const GeometrySourcePtr &geometry=nullptr)
ProgramPtr	_program (const GeometrySourcePtr &geometry)
ProgramPtr	_program (const std::string &vertexString)
ProgramPtr	_program (const std::string &vertexString, const std::string &fragmentString)
ProgramPtr	_program (const std::string &vertexString, const std::string &fragmentString, const std::string &geometryString)
std::shared_ptr< std::map< std::string, VariantPtr > >	_parameters (const std::map< std::string, VariantPtr > &parameters={})
std::shared_ptr< std::vector< StatePtr > >	_states (const std::vector< StatePtr > &states={})
MaterialPtr	_material (const ProgramPtr &program=nullptr, const std::shared_ptr< std::map< std::string, VariantPtr > > &parameters=nullptr, const std::shared_ptr< std::vector< StatePtr > > &states=nullptr)
MaterialPtr	_material (const ProgramPtr &program, const std::shared_ptr< std::vector< StatePtr > > &states)
MaterialPtr	_material (const std::shared_ptr< std::map< std::string, VariantPtr > > &parameters, const std::shared_ptr< std::vector< StatePtr > > &states=nullptr)
MaterialPtr	_material (const std::vector< SourcePtr > &sources, const std::map< std::string, VariantPtr > &parameters, const std::vector< StatePtr > &states)
MaterialPtr	_material (const std::vector< SourcePtr > &sources, const std::map< std::string, VariantPtr > &parameters)
MaterialPtr	_material (const std::vector< SourcePtr > &sources, const std::vector< StatePtr > &states)
MaterialPtr	_material (const std::vector< SourcePtr > &sources)
MaterialPtr	_material (const ProgramPtr &program, const std::map< std::string, VariantPtr > &parameters, const std::vector< StatePtr > &states)
MaterialPtr	_material (const ProgramPtr &program, const std::map< std::string, VariantPtr > &parameters)
MaterialPtr	_material (const ProgramPtr &program, const std::vector< StatePtr > &states)
MaterialPtr	_material (const std::map< std::string, VariantPtr > &parameters, const std::vector< StatePtr > &states)
MaterialPtr	_material (const std::map< std::string, VariantPtr > &parameters)
MaterialPtr	_material (const std::vector< StatePtr > &states)
BackgroundPtr	_background (const Vector2iPtr &size, const Color4fPtr &colorMask=nullptr, const RealPtr &depthMask=nullptr, const IntegerPtr &stencilMask=nullptr, const Vector2iPtr &coordinate=_ivec2())
BackgroundPtr	_simpleBackground (const Vector2iPtr &size, const Color4fPtr &colorMask=_clr4(0.7, 0.7, 0.7, 1.0), const RealPtr &depthMask=_real(1.0), const IntegerPtr &stencilMask=nullptr, const Vector2iPtr &coordinate=_ivec2())
ImageBufferPtr	_colorBuf ()
TargetPtr	_target ()
TargetPtr	_target (const std::vector< ImageBufferPtr > &array)
PrimitivePtr	_primitive (const GeometryPtr &geometry=nullptr, const MaterialPtr &material=nullptr, int priority=0)
PrimitivePtr	_primitive (const MaterialPtr &material, int priority=0)
CameraPtr	_camera (const Matrix4fPtr &viewMatrix=_mat4(), const Matrix4fPtr &projectionMatrix=_mat4(), const Vector3fPtr &orbitPoint=_vec3())
std::shared_ptr< std::vector< PrimitivePtr > >	_primitives (const std::vector< PrimitivePtr > &primitives={})
MeshPtr	_mesh (const std::shared_ptr< std::vector< PrimitivePtr > > &primitives=nullptr, const BoundingBoxPtr &boundingBox=nullptr)
MeshPtr	_mesh (const std::vector< PrimitivePtr > &primitives, const BoundingBoxPtr &boundingBox=nullptr)
NodePtr	_node (const MeshPtr &mesh=nullptr, const std::shared_ptr< std::vector< NodePtr > > &children=nullptr, const Matrix4fPtr &transform=nullptr, const BoundingBoxPtr &boundingBox=nullptr, const std::string &name="Node", const MaterialPtr &material=nullptr, const GeometryPtr &geometry=nullptr, const QueryPtr &query=nullptr)
NodePtr	_node (const std::shared_ptr< std::vector< NodePtr > > &children, const Matrix4fPtr &transform=nullptr, const BoundingBoxPtr &boundingBox=nullptr, const std::string &name="Node", const MaterialPtr &material=nullptr, const GeometryPtr &geometry=nullptr, const QueryPtr &query=nullptr)
NodePtr	_node (const std::vector< PrimitivePtr > &primitives, const Matrix4fPtr &transform=nullptr)
NodePtr	_node (const std::vector< NodePtr > &nodes, const Matrix4fPtr &transform=nullptr)
NodePtr	_node (const std::vector< PrimitivePtr > &primitives, const std::vector< NodePtr > &nodes, const Matrix4fPtr &transform=nullptr)
std::shared_ptr< std::vector< NodePtr > >	_nodes (const std::vector< NodePtr > &nodes={})
PassPtr	_pass (const NodePtr &node=nullptr, const BackgroundPtr &background=nullptr, const CameraPtr &camera=nullptr, const TargetPtr &target=nullptr, const std::string &name="Pass", bool enabled=true)
ScenePtr	_scene (const std::shared_ptr< std::vector< PassPtr > > &passes=nullptr, const BoundingBoxPtr &boundingBox=nullptr, const std::string &name="Scene")
ScenePtr	_scene (const std::vector< PassPtr > &passes, const BoundingBoxPtr &boundingBox=nullptr, const std::string &name="Scene")
Box2iPtr	_box2i ()
Box2iPtr	_box2i (int xmin, int xmax, int ymin, int ymax)
Box2iPtr	_box2i (const Vector2i &min, const Vector2i &max)
Box2iPtr	_box2i (const Box2i &other)
Box2fPtr	_box2f ()
Box2fPtr	_box2f (float xmin, float xmax, float ymin, float ymax)
Box2fPtr	_box2f (const Vector2f &min, const Vector2f &max)
Box2fPtr	_box2f (const Box2f &other)
Box3iPtr	_box3i ()
Box3iPtr	_box3i (int xmin, int xmax, int ymin, int ymax, int zmin, int zmax)
Box3iPtr	_box3i (const Vector3i &min, const Vector3i &max)
Box3iPtr	_box3i (const Box3i &other)
Box3fPtr	_box3f ()
Box3fPtr	_box3f (float xmin, float xmax, float ymin, float ymax, float zmin, float zmax)
Box3fPtr	_box3f (const Vector3f &min, const Vector3f &max)
Box3fPtr	_box3f (const Box3f &other)
BoundingBoxPtr	_bbox ()
BoundingBoxPtr	_bbox (float xmin, float xmax, float ymin, float ymax, float zmin, float zmax)
BoundingBoxPtr	_bbox (const Vector3f &min, const Vector3f &max)
BoundingBoxPtr	_bbox (const BoundingBox &other)
Color3fPtr	_clr3 ()
Color3fPtr	_clr3 (float r, float g, float b)
Color3fPtr	_clr3 (const Color3f &other)
Color3fPtr	_clr3 (const Color3ub &other)
Color3fPtr	_clr3 (const Color4f &other)
Color3fPtr	_clr3 (const Color4ub &other)
Color3ubPtr	_clr3ub ()
Color3ubPtr	_clr3ub (unsigned char r, unsigned char g, unsigned char b)
Color3ubPtr	_clr3ub (const Color3f &other)
Color3ubPtr	_clr3ub (const Color3ub &other)
Color3ubPtr	_clr3ub (const Color4f &other)
Color3ubPtr	_clr3ub (const Color4ub &other)
Color4fPtr	_clr4 ()
Color4fPtr	_clr4 (float r, float g, float b, float a)
Color4fPtr	_clr4 (const Color3f &other)
Color4fPtr	_clr4 (const Color3ub &other)
Color4fPtr	_clr4 (const Color4f &other)
Color4fPtr	_clr4 (const Color4ub &other)
Color4ubPtr	_clr4ub ()
Color4ubPtr	_clr4ub (unsigned char r, unsigned char g, unsigned char b, unsigned char a)
Color4ubPtr	_clr4ub (const Color3f &other)
Color4ubPtr	_clr4ub (const Color3ub &other)
Color4ubPtr	_clr4ub (const Color4f &other)
Color4ubPtr	_clr4ub (const Color4ub &other)
Image2DPtr	_image2d (int width, int height, unsigned char *data=nullptr)
ImageCubePtr	_imageCube (const std::vector< Image2D > &images)
IntegerPtr	_integer ()
IntegerPtr	_integer (int v)
IntegerPtr	_integer (const Integer &other)
Matrix2fPtr	_mat2 ()
Matrix2fPtr	_mat2 (float e00, float e01, float e10, float e11)
Matrix2fPtr	_mat2 (const Vector2f &c0, const Vector2f &c1)
Matrix2fPtr	_mat2 (const Matrix2f &other)
Matrix2fPtr	_mat2 (const Matrix3f &other)
Matrix2fPtr	_mat2 (const Matrix4f &other)
Matrix3fPtr	_mat3 ()
Matrix3fPtr	_mat3 (float e00, float e01, float e02, float e10, float e11, float e12, float e20, float e21, float e22)
Matrix3fPtr	_mat3 (const Vector3f &c0, const Vector3f &c1, const Vector3f &c2)
Matrix3fPtr	_mat3 (const Matrix2f &other)
Matrix3fPtr	_mat3 (const Matrix3f &other)
Matrix3fPtr	_mat3 (const Matrix4f &other)
Matrix4fPtr	_mat4 ()
Matrix4fPtr	_mat4 (float e00, float e01, float e02, float e03, float e10, float e11, float e12, float e13, float e20, float e21, float e22, float e23, float e30, float e31, float e32, float e33)
Matrix4fPtr	_mat4 (const Vector4f &c0, const Vector4f &c1, const Vector4f &c2, const Vector4f &c3)
Matrix4fPtr	_mat4 (const Matrix2f &other)
Matrix4fPtr	_mat4 (const Matrix3f &other)
Matrix4fPtr	_mat4 (const Matrix4f &other)
MinMaxPtr	_minmax ()
MinMaxPtr	_minmax (float min, float max)
MinMaxPtr	_minmax (const MinMax &other)
PlanePtr	_plane ()
PlanePtr	_plane (float x, float y, float z, float w)
PlanePtr	_plane (const Vector3f &origin, const Vector3f &normal)
PlanePtr	_plane (const Plane &other)
QuaternionPtr	_quat ()
QuaternionPtr	_quat (float x, float y, float z, float w)
QuaternionPtr	_quat (const Vector3f &axis, float angle)
QuaternionPtr	_quat (const Quaternion &other)
RayPtr	_ray ()
RayPtr	_ray (const Vector3f &origin, const Vector3f &normal)
RayPtr	_ray (const Ray &other)
RealPtr	_real ()
RealPtr	_real (float v)
RealPtr	_real (const Real &other)
VertexSourcePtr	_vert (const std::string &text)
FragmentSourcePtr	_frag (const std::string &text)
GeometrySourcePtr	_geom (const std::string &text)
Int8ArrayPtr	_i8array (int size=0, char *data=nullptr, bool copy=true)
Int8ArrayPtr	_i8array (const std::initializer_list< char > &array)
Uint8ArrayPtr	_u8array (int size=0, unsigned char *data=nullptr, bool copy=true)
Uint8ArrayPtr	_u8array (const std::initializer_list< unsigned char > &array)
Int16ArrayPtr	_i16array (int size=0, short *data=nullptr, bool copy=true)
Int16ArrayPtr	_i16array (const std::initializer_list< short > &array)
Uint16ArrayPtr	_u16array (int size=0, unsigned short *data=nullptr, bool copy=true)
Uint16ArrayPtr	_u16array (const std::initializer_list< unsigned short > &array)
Int32ArrayPtr	_i32array (int size=0, int *data=nullptr, bool copy=true)
Int32ArrayPtr	_i32array (const std::initializer_list< int > &array)
Uint32ArrayPtr	_u32array (int size=0, unsigned int *data=nullptr, bool copy=true)
Uint32ArrayPtr	_u32array (const std::initializer_list< unsigned int > &array)
Float32ArrayPtr	_f32array (int size=0, float *data=nullptr, bool copy=true)
Float32ArrayPtr	_f32array (const std::initializer_list< float > &array)
Float64ArrayPtr	_f64array (int size=0, double *data=nullptr, bool copy=true)
Float64ArrayPtr	_f64array (const std::initializer_list< double > &array)
Vector2iPtr	_ivec2 ()
Vector2iPtr	_ivec2 (int x, int y)
Vector2iPtr	_ivec2 (const Vector2i &other)
Vector2iPtr	_ivec2 (const Vector3i &other)
Vector2iPtr	_ivec2 (const Vector4i &other)
Vector2fPtr	_vec2 ()
Vector2fPtr	_vec2 (float x, float y)
Vector2fPtr	_vec2 (const Vector2f &other)
Vector2fPtr	_vec2 (const Vector3f &other)
Vector2fPtr	_vec2 (const Vector4f &other)
Vector3iPtr	_ivec3 ()
Vector3iPtr	_ivec3 (int x, int y, int z)
Vector3iPtr	_ivec3 (const Vector2i &other, int z=0)
Vector3iPtr	_ivec3 (const Vector3i &other)
Vector3iPtr	_ivec3 (const Vector4i &other)
Vector3fPtr	_vec3 ()
Vector3fPtr	_vec3 (float x, float y, float z)
Vector3fPtr	_vec3 (const Vector2f &other, float z=0)
Vector3fPtr	_vec3 (const Vector3f &other)
Vector3fPtr	_vec3 (const Vector4f &other)
Vector4iPtr	_ivec4 ()
Vector4iPtr	_ivec4 (int x, int y, int z, int w)
Vector4iPtr	_ivec4 (const Vector2i &other, int z=0, int w=0)
Vector4iPtr	_ivec4 (const Vector3i &other, int w=0)
Vector4iPtr	_ivec4 (const Vector4i &other)
Vector4fPtr	_vec4 ()
Vector4fPtr	_vec4 (float x, float y, float z, float w)
Vector4fPtr	_vec4 (const Vector2f &other, float z=0, float w=0)
Vector4fPtr	_vec4 (const Vector3f &other, float w=0)
Vector4fPtr	_vec4 (const Vector4f &other)
std::shared_ptr< Timer >	_timer ()
BoundingBoxPtr	getBoundingBox (const GeometryPtr &geometry, const std::string &attribName="positions")
BoundingBoxPtr	getBoundingBox (const PrimitivePtr &primitive)
BoundingBoxPtr	getBoundingBox (const MeshPtr &mesh)
BoundingBoxPtr	getBoundingBox (const NodePtr &node)
BoundingBoxPtr	getBoundingBox (const PassPtr &pass)
BoundingBoxPtr	getBoundingBox (const ScenePtr &scene)
Vector2f	getOrthoSize (const Matrix4f &matrix)
	Calculates the width and height of the orthographic projection matrix, and returns a Vector2f object containing the calculated width and height.
void	setOrthoSize (Matrix4f &matrix, const Vector2f &size)
	Modifying a projection matrix with a desired size of orthographic view.
MinMax	getOrthoMinMax (const Matrix4f &matrix)
	Calculates the near and far clipping planes of the orthographic projection.
void	setOrthoMinMax (Matrix4f &matrix, const MinMax &mm)
	Modifying a projection matrix with a desired near and far clipping planes for the orthographic projection.
float	getAspect (const Matrix4f &matrix)
	Gets the aspect ratio of an orthographic projection matrix.
void	setAspect (Matrix4f &matrix, float aspect)
	Scales the width of a orthographic view based on the desired aspect ratio while keeping the height constant.
ViewSpec	getViewSpec (const Matrix4f &matrix)
	Gets the ViewSpec vectors from a specified matrix.
void	setViewSpec (Matrix4f &matrix, const ViewSpec &viewSpec)
	Sets the ViewSpec to the matrix, It can change the matrix elements.
void	lookAt (Matrix4f &viewMatrix, const Vector3f &eye, const Vector3f &vrp, const Vector3f &up)
std::shared_ptr< Axis >	_axis (const std::shared_ptr< Vector2i > &coordinate, const std::shared_ptr< Vector2i > &backgroundSize)
std::shared_ptr< LegendPass >	_legendPass (const std::shared_ptr< Vector2i > &backgroundSize)
std::shared_ptr< Scale >	_scale (const std::shared_ptr< Camera > &camera, const std::shared_ptr< Background > &background)
std::shared_ptr< FullViewCube >	_fullViewCube (const std::shared_ptr< Renderer > &renderer, const std::shared_ptr< Image2D > &image, const std::shared_ptr< Vector2i > &coordinate, const std::shared_ptr< Vector2i > &backgroundSize, const std::shared_ptr< Vector2i > &windowSize)
std::shared_ptr< MiniViewCube >	_miniViewCube (const std::shared_ptr< Renderer > &renderer, const std::shared_ptr< Image2D > &image, const std::shared_ptr< Vector2i > &coordinate, const std::shared_ptr< Vector2i > &backgroundSize, const std::shared_ptr< Vector2i > &windowSize)
std::shared_ptr< CornerViewCube >	_cornerViewCube (const std::shared_ptr< Renderer > &renderer, const std::shared_ptr< Image2D > &image, const std::shared_ptr< Vector2i > &coordinate, const std::shared_ptr< Vector2i > &backgroundSize, const std::shared_ptr< Vector2i > &windowSize)
std::shared_ptr< Geometry >	_spline (const std::vector< Vector3f > control_points, int degree, BSplineCurve::Boundary boundary, const int slices)
std::shared_ptr< Geometry >	_spline_fit (const std::vector< Vector3f > fit_points, BSplineCurve::Boundary boundary, const int slices)
std::shared_ptr< Geometry >	_geometry_arrow ()
std::shared_ptr< Geometry >	_geometry_capsule (const float radius=1.0, const float height=2.0, const int slices=24, const int stacks=24)
std::shared_ptr< Geometry >	_geometry_cone (const float radius=1.0, const float height=1.0, const int slices=36)
std::shared_ptr< Geometry >	_geometry_cube (const Vector3f &min=vec3(-1, -1, -1), const Vector3f &max=vec3(1, 1, 1))
std::shared_ptr< Geometry >	_geometry_cube_outline (const Vector3f &min=vec3(-1, -1, -1), const Vector3f &max=vec3(1, 1, 1))
std::shared_ptr< Geometry >	_geometry_cylinder (const float radius=1.0, const float height=1.0, const int slices=36)
std::shared_ptr< Geometry >	_geometry_disk (const float radius=1, const int slices=36)
std::shared_ptr< Geometry >	_geometry_pipe (const float radius=1.0, const float height=1.0, const int slices=36)
std::shared_ptr< Geometry >	_geometry_quad (const Vector3f &v0=vec3(-1, -1, 0), const Vector3f &v1=vec3(1, -1, 0), const Vector3f &v2=vec3(1, 1, 0), const Vector3f &v3=vec3(-1, 1, 0))
std::shared_ptr< Geometry >	_geometry_sphere (const float radius=1.0, const int slices=24, const int stacks=24)
std::shared_ptr< Geometry >	_geometry_torus (const float radius=1.0, const float tubeRadius=0.1, const int sides=20, const int rings=30)
std::shared_ptr< Geometry >	_geometry_triangle (const Vector3f &v0=vec3(-1, -1, 0), const Vector3f &v1=vec3(1, -1, 0), const Vector3f &v2=vec3(0, 1, 0))
std::shared_ptr< Geometry >	_geometry_unit_cube ()
std::shared_ptr< Geometry >	_geometry_unit_cube_outline ()
std::shared_ptr< Geometry >	_geometry_unit_sphere ()
std::shared_ptr< Clipper >	_clipper ()
std::shared_ptr< PlaneClipping >	_planeClipping ()
std::shared_ptr< PlaneClipping >	_planeClipping (float a, float b, float c, float d)
std::shared_ptr< PlaneClipping >	_planeClipping (const std::shared_ptr< Vector3f > &origin, const std::shared_ptr< Vector3f > &normal)
std::shared_ptr< TwoPlaneClipping >	_2planeClipping ()
std::shared_ptr< TwoPlaneClipping >	_2planeClipping (const std::shared_ptr< Vector3f > &origin1, const std::shared_ptr< Vector3f > &normal1, const std::shared_ptr< Vector3f > &origin2, const std::shared_ptr< Vector3f > &normal2)
std::shared_ptr< SphereClipping >	_sphereClipping ()
std::shared_ptr< SphereClipping >	_sphereClipping (float a, float b, float c, float d)
std::shared_ptr< SphereClipping >	_sphereClipping (const std::shared_ptr< Vector3f > &position, float radius)
std::shared_ptr< Exploder >	_exploder ()
std::shared_ptr< AxialTransformPath >	_axialTransformPath ()
std::shared_ptr< AxialTransformPath >	_axialTransformPath (const std::shared_ptr< Vector3f > &origin, const std::shared_ptr< Vector3f > &direction)
std::shared_ptr< RadialTransformPath >	_radialTransformPath ()
std::shared_ptr< RadialTransformPath >	_radialTransformPath (const std::shared_ptr< Vector3f > &origin, const std::shared_ptr< Vector3f > &normal)
std::shared_ptr< SpaceTransformPath >	_spaceTransformPath ()
std::shared_ptr< SpaceTransformPath >	_spaceTransformPath (const std::shared_ptr< Vector3f > &origin)
std::shared_ptr< CompositeLocator >	_compositeLocator (const std::shared_ptr< Locator > &origin, const std::shared_ptr< ShapeLocator > &shape)
std::shared_ptr< LineHandler >	_lineHandler (const std::shared_ptr< Matrix4f > &matrix)
std::shared_ptr< ArcHandler >	_arcHandler (const std::shared_ptr< Matrix4f > &matrix)
std::shared_ptr< ShapeHandler >	_shapeHandler (const std::shared_ptr< Matrix4f > &matrix)
std::shared_ptr< ArrowLocator >	_arrowLocator ()
std::shared_ptr< PositionLocator >	_positionLocator ()
std::shared_ptr< OrientationLocator >	_orientationLocator ()
std::shared_ptr< PlaneLocator >	_planeLocator ()
std::shared_ptr< DiskLocator >	_diskLocator ()
std::shared_ptr< BoxLocator >	_boxLocator ()
std::shared_ptr< BottomBoxLocator >	_bottomBoxLocator ()
std::shared_ptr< CylinderLocator >	_cylinderLocator ()
std::shared_ptr< BottomCylinderLocator >	_bottomCylinderLocator ()
std::shared_ptr< SphereLocator >	_sphereLocator ()
std::shared_ptr< LocatorPass >	_locatorPass (const std::shared_ptr< Background > &background, const std::shared_ptr< Camera > &camera)
std::shared_ptr< MouseManipulator >	_manipulator ()
std::shared_ptr< PanAction >	_panAction (std::shared_ptr< MouseDraggedAction > successor, std::shared_ptr< Camera > camera, std::shared_ptr< Vector2i > windowSize)
std::shared_ptr< OrbitAction >	_orbitAction (std::shared_ptr< MouseDraggedAction > successor, std::shared_ptr< Camera > camera, std::shared_ptr< Vector2i > windowSize, std::shared_ptr< BoundingBox > boundingBox=nullptr)
std::shared_ptr< RollAction >	_rollAction (std::shared_ptr< MouseDraggedAction > successor, std::shared_ptr< Camera > camera, std::shared_ptr< Vector2i > windowSize)
std::shared_ptr< ZoomAction >	_zoomAction (std::shared_ptr< MouseWheeledAction > successor, std::shared_ptr< Camera > camera, std::shared_ptr< Vector2i > windowSize)
std::shared_ptr< NavigationManipulator >	_manipulator_navigation (std::shared_ptr< Camera > &camera, const std::shared_ptr< Vector2i > &windowSize, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)
std::shared_ptr< Material >	_material_unlight (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_unlight (const std::shared_ptr< Image2D > &image)
std::shared_ptr< Material >	_material_unlight (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	_material_unlight (const std::shared_ptr< ImageCube > &image)
std::shared_ptr< Material >	_material_head_light (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_head_light (const std::shared_ptr< Image2D > &image)
std::shared_ptr< Material >	_material_head_light (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	_material_head_light (const std::shared_ptr< ImageCube > &image)
std::shared_ptr< Material >	_material_strip (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_strip (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Integer > &strips)
std::shared_ptr< Material >	_material_scale (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_scale (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	_material_gouraud (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_gouraud (const std::shared_ptr< Image2D > &image)
std::shared_ptr< Material >	_material_gouraud (const std::shared_ptr< ImageCube > &image)
std::shared_ptr< Material >	_material_flat (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_phong (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_phong (const std::shared_ptr< Image2D > &image)
std::shared_ptr< Material >	_material_phong (const std::shared_ptr< ImageCube > &image)
std::shared_ptr< Material >	_material_outline (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_outline (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	_material_shaded (const std::shared_ptr< Color3f > &color)
std::shared_ptr< Material >	_material_shaded (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	_material_unlight_transparent (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &alpha)
std::shared_ptr< Material >	_material_transparent (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &alpha)
std::shared_ptr< Material >	_material_transparent (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &alpha)
std::shared_ptr< Material >	_material_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	_material_sphere (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	_material_fixed_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	_material_fixed_sphere (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	_material_vector (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_vector (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_fixed_vector (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_fixed_vector (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_block (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_block (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_block_outline (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_streamline (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	_material_streamline (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	_material_ribbon (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	_material_ribbon (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	_material_cylinder (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	_material_cylinder (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	_material_offset_outline (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_outline (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_shaded (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_shaded (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_strip (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_strip (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Integer > &strips, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_transparent (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &alpha, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_transparent (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &alpha, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_sphere (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_fixed_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_fixed_sphere (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_cylinder (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_offset_cylinder (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	_material_forward_ribbon (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_ribbon (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_cylinder (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_cylinder (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_sphere (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_fixed_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_forward_fixed_sphere (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_meteor_cylinder (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &length, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_meteor_cylinder (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &length, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_meteor_line (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &length, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_meteor_line (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &length, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	_material_point_sprites_square (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_disc (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_spiral (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_rose (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_sphere (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_star (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_circle (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_grid (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_point_sprites_icon (const std::shared_ptr< Image2D > &image, const std::shared_ptr< Real > &pointSize=_real(24.0))
std::shared_ptr< Material >	_material_cloud (const std::shared_ptr< Color3f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &radius)
std::shared_ptr< Material >	_material_cloud (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &radius)
std::shared_ptr< Material >	_material_line (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &width=_real(1.0f), LineStyle style=LineStyle::Solid)
std::shared_ptr< Material >	_material_pbr (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &metallic, const std::shared_ptr< Real > &roughness)
std::shared_ptr< Material >	_material_pbr (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Real > &metallic, const std::shared_ptr< Real > &roughness, const std::shared_ptr< ImageCube > &image)
std::shared_ptr< FragmentSource >	_fragment_vertex_color ()
std::shared_ptr< VertexSource >	_vertex_unlight_color ()
std::shared_ptr< FragmentSource >	_fragment_unlight_color ()
std::shared_ptr< VertexSource >	_vertex_unlight_texture ()
std::shared_ptr< FragmentSource >	_fragment_unlight_texture ()
std::shared_ptr< VertexSource >	_vertex_unlight_scalar ()
std::shared_ptr< VertexSource >	_vertex_unlight_cube_texture ()
std::shared_ptr< FragmentSource >	_fragment_unlight_cube_texture ()
std::shared_ptr< VertexSource >	_vertex_head_light_color ()
std::shared_ptr< FragmentSource >	_fragment_head_light_color ()
std::shared_ptr< VertexSource >	_vertex_head_light_texture ()
std::shared_ptr< FragmentSource >	_fragment_head_light_texture ()
std::shared_ptr< VertexSource >	_vertex_head_light_scalar ()
std::shared_ptr< FragmentSource >	_fragment_head_light_scalar ()
std::shared_ptr< VertexSource >	_vertex_head_light_cube_texture ()
std::shared_ptr< FragmentSource >	_fragment_head_light_cube_texture ()
std::shared_ptr< FragmentSource >	_fragment_strip_scalar ()
std::shared_ptr< VertexSource >	_vertex_scale_color ()
std::shared_ptr< GeometrySource >	_geometry_scale_color ()
std::shared_ptr< FragmentSource >	_fragment_scale_color ()
std::shared_ptr< VertexSource >	_vertex_scale_scalar ()
std::shared_ptr< GeometrySource >	_geometry_scale_scalar ()
std::shared_ptr< FragmentSource >	_fragment_scale_scalar ()
std::shared_ptr< VertexSource >	_vertex_gouraud_color ()
std::shared_ptr< FragmentSource >	_fragment_gouraud_color ()
std::shared_ptr< VertexSource >	_vertex_gouraud_texture ()
std::shared_ptr< FragmentSource >	_fragment_gouraud_texture ()
std::shared_ptr< VertexSource >	_vertex_gouraud_cube_texture ()
std::shared_ptr< FragmentSource >	_fragment_gouraud_cube_texture ()
std::shared_ptr< VertexSource >	_vertex_phong_color ()
std::shared_ptr< FragmentSource >	_fragment_phong_color ()
std::shared_ptr< VertexSource >	_vertex_phong_texture ()
std::shared_ptr< FragmentSource >	_fragment_phong_texture ()
std::shared_ptr< VertexSource >	_vertex_phong_scalar ()
std::shared_ptr< FragmentSource >	_fragment_phong_scalar ()
std::shared_ptr< VertexSource >	_vertex_phong_cube_texture ()
std::shared_ptr< FragmentSource >	_fragment_phong_cube_texture ()
std::shared_ptr< VertexSource >	_vertex_flat_color ()
std::shared_ptr< FragmentSource >	_fragment_flat_color ()
std::shared_ptr< FragmentSource >	_fragment_unlight_color_transparent ()
std::shared_ptr< VertexSource >	_vertex_transparent_color ()
std::shared_ptr< FragmentSource >	_fragment_transparent_color ()
std::shared_ptr< VertexSource >	_vertex_transparent_scalar ()
std::shared_ptr< FragmentSource >	_fragment_transparent_scalar ()
std::shared_ptr< VertexSource >	_vertex_block_color ()
std::shared_ptr< VertexSource >	_vertex_block_scalar ()
std::shared_ptr< VertexSource >	_vertex_block_outline ()
std::shared_ptr< VertexSource >	_vertex_vector_color ()
std::shared_ptr< VertexSource >	_vertex_vector_scalar ()
std::shared_ptr< VertexSource >	_vertex_fixed_vector_color ()
std::shared_ptr< VertexSource >	_vertex_fixed_vector_scalar ()
std::shared_ptr< VertexSource >	_vertex_sphere_color ()
std::shared_ptr< FragmentSource >	_fragment_sphere_color ()
std::shared_ptr< VertexSource >	_vertex_sphere_scalar ()
std::shared_ptr< FragmentSource >	_fragment_sphere_scalar ()
std::shared_ptr< VertexSource >	_vertex_fixed_sphere_color ()
std::shared_ptr< VertexSource >	_vertex_fixed_sphere_scalar ()
std::shared_ptr< VertexSource >	_vertex_ribbon_color ()
std::shared_ptr< GeometrySource >	_geometry_ribbon_color ()
std::shared_ptr< FragmentSource >	_fragment_ribbon_color ()
std::shared_ptr< VertexSource >	_vertex_ribbon_scalar ()
std::shared_ptr< GeometrySource >	_geometry_ribbon_scalar ()
std::shared_ptr< FragmentSource >	_fragment_ribbon_scalar ()
std::shared_ptr< GeometrySource >	_geometry_cylinder_color ()
std::shared_ptr< FragmentSource >	_fragment_cylinder_color ()
std::shared_ptr< GeometrySource >	_geometry_cylinder_scalar ()
std::shared_ptr< FragmentSource >	_fragment_cylinder_scalar ()
std::shared_ptr< VertexSource >	_vertex_offset_outline_color ()
std::shared_ptr< VertexSource >	_vertex_offset_outline_scalar ()
std::shared_ptr< VertexSource >	_vertex_offset_shaded_color ()
std::shared_ptr< VertexSource >	_vertex_offset_shaded_scalar ()
std::shared_ptr< VertexSource >	_vertex_offset_sphere_color ()
std::shared_ptr< VertexSource >	_vertex_offset_sphere_scalar ()
std::shared_ptr< VertexSource >	_vertex_offset_fixed_sphere_color ()
std::shared_ptr< VertexSource >	_vertex_offset_fixed_sphere_scalar ()
std::shared_ptr< VertexSource >	_vertex_offset_cylinder_color ()
std::shared_ptr< VertexSource >	_vertex_offset_cylinder_scalar ()
std::shared_ptr< VertexSource >	_vertex_forward_ribbon_color ()
std::shared_ptr< GeometrySource >	_geometry_forward_ribbon_color ()
std::shared_ptr< FragmentSource >	_fragment_forward_ribbon_color ()
std::shared_ptr< VertexSource >	_vertex_forward_ribbon_scalar ()
std::shared_ptr< GeometrySource >	_geometry_forward_ribbon_scalar ()
std::shared_ptr< FragmentSource >	_fragment_forward_ribbon_scalar ()
std::shared_ptr< GeometrySource >	_geometry_forward_cylinder_color ()
std::shared_ptr< FragmentSource >	_fragment_forward_cylinder_color ()
std::shared_ptr< GeometrySource >	_geometry_forward_cylinder_scalar ()
std::shared_ptr< FragmentSource >	_fragment_forward_cylinder_scalar ()
std::shared_ptr< VertexSource >	_vertex_forward_sphere_color ()
std::shared_ptr< FragmentSource >	_fragment_forward_sphere_color ()
std::shared_ptr< VertexSource >	_vertex_forward_sphere_scalar ()
std::shared_ptr< FragmentSource >	_fragment_forward_sphere_scalar ()
std::shared_ptr< VertexSource >	_vertex_forward_fixed_sphere_color ()
std::shared_ptr< FragmentSource >	_fragment_forward_fixed_sphere_color ()
std::shared_ptr< VertexSource >	_vertex_forward_fixed_sphere_scalar ()
std::shared_ptr< FragmentSource >	_fragment_forward_fixed_sphere_scalar ()
std::shared_ptr< VertexSource >	_vertex_meteor_cylinder_color ()
std::shared_ptr< GeometrySource >	_geometry_meteor_cylinder_color ()
std::shared_ptr< FragmentSource >	_fragment_meteor_cylinder_color ()
std::shared_ptr< VertexSource >	_vertex_meteor_cylinder_scalar ()
std::shared_ptr< GeometrySource >	_geometry_meteor_cylinder_scalar ()
std::shared_ptr< FragmentSource >	_fragment_meteor_cylinder_scalar ()
std::shared_ptr< VertexSource >	_vertex_meteor_line_color ()
std::shared_ptr< FragmentSource >	_fragment_meteor_line_color ()
std::shared_ptr< VertexSource >	_vertex_meteor_line_scalar ()
std::shared_ptr< FragmentSource >	_fragment_meteor_line_scalar ()
std::shared_ptr< VertexSource >	_vertex_point_sprites ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_square ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_disc ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_spiral ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_rose ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_sphere ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_star ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_circle ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_grid ()
std::shared_ptr< FragmentSource >	_fragment_point_sprites_icon ()
std::shared_ptr< VertexSource >	_vertex_cloud_color ()
std::shared_ptr< FragmentSource >	_fragment_cloud_color ()
std::shared_ptr< VertexSource >	_vertex_cloud_scalar ()
std::shared_ptr< FragmentSource >	_fragment_cloud_scalar ()
std::shared_ptr< VertexSource >	_vertex_line ()
std::shared_ptr< GeometrySource >	_geometry_line_dotdash ()
std::shared_ptr< GeometrySource >	_geometry_line_width ()
std::shared_ptr< GeometrySource >	_geometry_line_dotdash_width ()
std::shared_ptr< FragmentSource >	_fragment_line_solid ()
std::shared_ptr< FragmentSource >	_fragment_line_dash ()
std::shared_ptr< FragmentSource >	_fragment_line_dot ()
std::shared_ptr< FragmentSource >	_fragment_line_dashdot ()
std::shared_ptr< FragmentSource >	_fragment_line_dashdotdot ()
std::shared_ptr< Depth >	_depth_opaque ()
std::shared_ptr< Depth >	_depth_transparent ()
std::shared_ptr< PolygonOffset >	_polygonOffset_opaque ()
std::shared_ptr< PolygonOffset >	_polygonOffset_transparent ()
std::shared_ptr< Culling >	_culling_glyph ()
std::shared_ptr< Point >	_point_sphere ()
std::shared_ptr< Point >	_point_point_sprites ()
std::shared_ptr< Blend >	_blend_transparent ()
std::shared_ptr< Material >	_material_toon (const std::shared_ptr< Color3f > &color, const std::shared_ptr< Integer > &level=_integer(6))
std::shared_ptr< std::vector< std::shared_ptr< Pass > > >	_filterImage (const std::shared_ptr< Pass > &input, const std::vector< FilterFunction > &filters)
std::shared_ptr< Material >	_imageProcessMaterial (const std::shared_ptr< ImageBuffer > &image, const std::string &snippet, const std::string &declaration="")
std::shared_ptr< Pass >	_imageProcess (const std::shared_ptr< Pass > &input, const std::string &snippet, const std::string &declaration="")
std::shared_ptr< Pass >	_luminance (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_sobel (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_prewitt (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_erode (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_dilate (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_imageConvolute (const std::shared_ptr< Pass > &input, const std::shared_ptr< Matrix3f > &factor)
std::shared_ptr< Pass >	_gaussianBlur (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_boxBlur (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_triangleBlur (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_laplacian (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_edgeDetection (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_sharpen (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_intenseSharpen (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_emboss (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_edgeEnhancement (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_silhouette (const std::shared_ptr< Pass > &input)
std::shared_ptr< Pass >	_mixPass (const std::shared_ptr< Pass > &input)
template<typename T >
std::shared_ptr< PassThroughFaceSelector< T > >	_passThroughFaceSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options)
template<typename T >
std::shared_ptr< PassThroughVertexSelector< T > >	_passThroughVertexSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options)
template<typename T >
std::shared_ptr< PassThroughEdgeSelector< T > >	_passThroughEdgeSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options)
std::shared_ptr< SelectorEngine >	_selectorEngine (const std::shared_ptr< Renderer > &renderer, const std::shared_ptr< Camera > &camera, const std::shared_ptr< Vector2i > &backgroundSize, const std::shared_ptr< Vector2i > &windowSize)
template<typename T >
std::shared_ptr< SelectorOptions< T > >	_selectorOptions (const std::shared_ptr< std::vector< std::shared_ptr< T > > > &entities, const std::function< std::shared_ptr< Node >(std::shared_ptr< T >)> &entity2node)
template<typename T >
std::shared_ptr< FaceSelector< T > >	_faceSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options, bool buffered=true)
template<typename T >
std::shared_ptr< VertexSelector< T > >	_vertexSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options, bool buffered=true)
template<typename T >
std::shared_ptr< EdgeSelector< T > >	_edgeSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options, bool buffered=true)
template<typename T >
std::shared_ptr< PositionSelector< T > >	_positionSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options, bool buffered=false)
template<typename T >
std::shared_ptr< NormalSelector< T > >	_normalSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options, bool buffered=false)
template<typename T >
std::shared_ptr< PrimitiveSelector< T > >	_primitiveSelector (const std::shared_ptr< SelectorEngine > &engine, const std::shared_ptr< SelectorOptions< T > > &options, bool buffered=false)
VizPartPtr	extractDataPart (const DataPartPtr &dataPart, const Parameters &parameters)
VizPartPtrMap	extractDataModel (const DataModelPtr &dataModel, const Parameters &parameters)
DataSolutionPtr	readVTKFile (const std::string &strFileName)
DataSolutionPtr	readVTUFile (const std::string &strFileName)
DataSolutionPtr	readVTIFile (const std::string &strFileName)
DataSolutionPtr	readVTPFile (const std::string &strFileName)
DataSolutionPtr	readVTSFile (const std::string &strFileName)
DataSolutionPtr	readVTRFile (const std::string &strFileName)
DataSolutionPtr	readVTMFile (const std::string &strFileName)
DataSolutionPtr	readPVDFile (const std::string &fileName)
DataSolutionPtr	readGambitFile (const std::string &strFileName)
DataSolutionPtr	readTecplotFile (const std::string &strFileName)
DataSolutionPtr	readLSDynaFile (const std::string &strFileName)
DataSolutionPtr	readOpenFoamFile (const std::string &strFileName)
DataSolutionPtr	readEnSightFile (const std::string &strFileName)
DataSolutionPtr	readCGNSFile (const std::string &strFileName)
DataSolutionPtr	readDICOMFile (const std::string &strFileName)
DataSolutionPtr	readSLCFile (const std::string &strFileName)
DataSolutionPtr	readBYUFile (const std::string &strFileName)
DataSolutionPtr	readSTLFile (const std::string &strFileName)
DataSolutionPtr	readPLYFile (const std::string &strFileName)
DataSolutionPtr	readOBJFile (const std::string &strFileName)
DataSolutionPtr	openSolution (const std::string &fileName, const std::string &typeName="AUTO")
std::shared_ptr< Node >	createBodyNode (const VizBodyPtr &vizBody, const Attributes &attributes, const std::shared_ptr< ScenarioSettings > &settings)
Attributes::Display	operator| (Attributes::Display display1, Attributes::Display display2)
Attributes::Display	operator& (Attributes::Display display1, Attributes::Display display2)
AttributesOverwriterPtr	makeAttributesOverwriter (AttributesOverwriter callback)
std::shared_ptr< Geometry >	vizArrowGeometry ()
std::shared_ptr< Geometry >	vizBallGeometry ()
std::shared_ptr< Geometry >	vizCubeGeometry ()
std::shared_ptr< Geometry >	vizCubeLineGeometry ()
std::shared_ptr< Material >	vizUnlightMaterial (const std::shared_ptr< Color4f > &color)
std::shared_ptr< Material >	vizUnlightMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	vizUnlightOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizUnlightOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizShadedMaterial (const std::shared_ptr< Color4f > &color)
std::shared_ptr< Material >	vizShadedMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	vizShadedOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizShadedOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizShrinkMaterial (const std::shared_ptr< Color4f > &color)
std::shared_ptr< Material >	vizShrinkMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	vizShrinkOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizShrinkOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizStripMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Integer > &strips)
std::shared_ptr< Material >	vizStripMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Integer > &strips)
std::shared_ptr< Material >	vizStripOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Integer > &strips, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizStripOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Integer > &strips, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizTransparentMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &alpha)
std::shared_ptr< Material >	vizTransparentMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &alpha)
std::shared_ptr< Material >	vizTransparentOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &alpha, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizTransparentOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &alpha, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizEnvironmentMappingMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< ImageCube > &envMappingImage)
std::shared_ptr< Material >	vizEnvironmentMappingMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< ImageCube > &envMappingImage)
std::shared_ptr< Material >	vizEnvironmentMappingOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< ImageCube > &envMappingImage, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizEnvironmentMappingOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< ImageCube > &envMappingImage, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizFlatMaterial (const std::shared_ptr< Color4f > &color)
std::shared_ptr< Material >	vizFlatMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range)
std::shared_ptr< Material >	vizFlatOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizFlatOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizPositionMaterial ()
std::shared_ptr< Material >	vizPositionOffsetMaterial (const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizNormalMaterial ()
std::shared_ptr< Material >	vizNormalOffsetMaterial (const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizWidthLineMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	vizWidthLineMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	vizWidthLineOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizWidthLineOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRibbonMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	vizRibbonMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	vizRibbonOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRibbonOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizCylinderMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	vizCylinderMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width)
std::shared_ptr< Material >	vizCylinderOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizCylinderOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizSphereMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizSphereMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizSphereOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizSphereOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizFixedSphereMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizFixedSphereMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizFixedSphereOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizFixedSphereOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizSquareMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizSquareMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizSquareOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizSquareOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizDiscMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizDiscMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizDiscOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizDiscOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRectMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizRectMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizRectOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRectOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizSpiralMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizSpiralMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizSpiralOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizSpiralOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRoseMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizRoseMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizRoseOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRoseOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizStarMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizStarMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizStarOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizStarOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRingMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizRingMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizRingOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizRingOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizDeltaMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizDeltaMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizDeltaOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizDeltaOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizDiamondMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizDiamondMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizDiamondOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizDiamondOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizAnimLineMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimLineMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimWidthMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimWidthMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimRibbonMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimRibbonMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimCylinderMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimCylinderMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizPtclSphereMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizPtclSphereMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizPtclFixedSphereMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizPtclFixedSphereMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimMeteorMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &length, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizAnimMeteorMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &width, const std::shared_ptr< Real > &length, const std::shared_ptr< Real > &currentTime)
std::shared_ptr< Material >	vizArrowMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizArrowMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizFixedArrowMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizFixedArrowMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizInstanceShadedMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizInstanceShadedMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizInstanceLineMaterial (const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizCloudMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizCloudMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize)
std::shared_ptr< Material >	vizCloudOffsetMaterial (const std::shared_ptr< Color4f > &color, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< Material >	vizCloudOffsetMaterial (const std::shared_ptr< Image2D > &image, const std::shared_ptr< MinMax > &range, const std::shared_ptr< Real > &pointSize, const std::shared_ptr< Real > &factor)
std::shared_ptr< VertexSource >	vizUnlightColorVertex ()
std::shared_ptr< FragmentSource >	vizUnlightColorFragment ()
std::shared_ptr< VertexSource >	vizUnlightScalarVertex ()
std::shared_ptr< FragmentSource >	vizUnlightScalarFragment ()
std::shared_ptr< VertexSource >	vizUnlightColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizUnlightScalarOffsetVertex ()
std::shared_ptr< VertexSource >	vizShadedColorVertex ()
std::shared_ptr< FragmentSource >	vizShadedColorFragment ()
std::shared_ptr< VertexSource >	vizShadedScalarVertex ()
std::shared_ptr< FragmentSource >	vizShadedScalarFragment ()
std::shared_ptr< VertexSource >	vizShadedColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizShadedScalarOffsetVertex ()
std::shared_ptr< GeometrySource >	vizShrinkColorGeometry ()
std::shared_ptr< FragmentSource >	vizShrinkColorFragment ()
std::shared_ptr< GeometrySource >	vizShrinkScalarGeometry ()
std::shared_ptr< FragmentSource >	vizShrinkScalarFragment ()
std::shared_ptr< FragmentSource >	vizStripColorFragment ()
std::shared_ptr< FragmentSource >	vizStripScalarFragment ()
std::shared_ptr< FragmentSource >	vizTransparentColorFragment ()
std::shared_ptr< FragmentSource >	vizTransparentScalarFragment ()
std::shared_ptr< VertexSource >	vizEnvironmentMappingColorVertex ()
std::shared_ptr< FragmentSource >	vizEnvironmentMappingColorFragment ()
std::shared_ptr< VertexSource >	vizEnvironmentMappingScalarVertex ()
std::shared_ptr< FragmentSource >	vizEnvironmentMappingScalarFragment ()
std::shared_ptr< VertexSource >	vizEnvironmentMappingColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizEnvironmentMappingScalarOffsetVertex ()
std::shared_ptr< VertexSource >	vizFlatColorVertex ()
std::shared_ptr< FragmentSource >	vizFlatColorFragment ()
std::shared_ptr< FragmentSource >	vizFlatScalarFragment ()
std::shared_ptr< VertexSource >	vizFlatScalarVertex ()
std::shared_ptr< VertexSource >	vizFlatColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizFlatScalarOffsetVertex ()
std::shared_ptr< VertexSource >	vizPositionVertex ()
std::shared_ptr< FragmentSource >	vizPositionFragment ()
std::shared_ptr< VertexSource >	vizPositionOffsetVertex ()
std::shared_ptr< VertexSource >	vizNormalVertex ()
std::shared_ptr< FragmentSource >	vizNormalFragment ()
std::shared_ptr< VertexSource >	vizNormalOffsetVertex ()
std::shared_ptr< VertexSource >	vizWidthLineColorVertex ()
std::shared_ptr< GeometrySource >	vizWidthLineColorGeometry ()
std::shared_ptr< FragmentSource >	vizWidthLineColorFragment ()
std::shared_ptr< VertexSource >	vizWidthLineScalarVertex ()
std::shared_ptr< GeometrySource >	vizWidthLineScalarGeometry ()
std::shared_ptr< FragmentSource >	vizWidthLineScalarFragment ()
std::shared_ptr< VertexSource >	vizWidthLineColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizWidthLineScalarOffsetVertex ()
std::shared_ptr< GeometrySource >	vizRibbonColorGeometry ()
std::shared_ptr< FragmentSource >	vizRibbonColorFragment ()
std::shared_ptr< GeometrySource >	vizRibbonScalarGeometry ()
std::shared_ptr< FragmentSource >	vizRibbonScalarFragment ()
std::shared_ptr< GeometrySource >	vizCylinderColorGeometry ()
std::shared_ptr< FragmentSource >	vizCylinderColorFragment ()
std::shared_ptr< GeometrySource >	vizCylinderScalarGeometry ()
std::shared_ptr< FragmentSource >	vizCylinderScalarFragment ()
std::shared_ptr< VertexSource >	vizSphereColorVertex ()
std::shared_ptr< FragmentSource >	vizSphereColorFragment ()
std::shared_ptr< VertexSource >	vizSphereScalarVertex ()
std::shared_ptr< FragmentSource >	vizSphereScalarFragment ()
std::shared_ptr< VertexSource >	vizSphereColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizSphereScalarOffsetVertex ()
std::shared_ptr< VertexSource >	vizFixedSphereColorVertex ()
std::shared_ptr< VertexSource >	vizFixedSphereScalarVertex ()
std::shared_ptr< VertexSource >	vizFixedSphereColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizFixedSphereScalarOffsetVertex ()
std::shared_ptr< FragmentSource >	vizSquareColorFragment ()
std::shared_ptr< FragmentSource >	vizSquareScalarFragment ()
std::shared_ptr< FragmentSource >	vizDiscColorFragment ()
std::shared_ptr< FragmentSource >	vizDiscScalarFragment ()
std::shared_ptr< FragmentSource >	vizRectColorFragment ()
std::shared_ptr< FragmentSource >	vizRectScalarFragment ()
std::shared_ptr< FragmentSource >	vizSpiralColorFragment ()
std::shared_ptr< FragmentSource >	vizSpiralScalarFragment ()
std::shared_ptr< FragmentSource >	vizRoseColorFragment ()
std::shared_ptr< FragmentSource >	vizRoseScalarFragment ()
std::shared_ptr< FragmentSource >	vizStarColorFragment ()
std::shared_ptr< FragmentSource >	vizStarScalarFragment ()
std::shared_ptr< FragmentSource >	vizRingColorFragment ()
std::shared_ptr< FragmentSource >	vizRingScalarFragment ()
std::shared_ptr< FragmentSource >	vizDeltaColorFragment ()
std::shared_ptr< FragmentSource >	vizDeltaScalarFragment ()
std::shared_ptr< FragmentSource >	vizDiamondColorFragment ()
std::shared_ptr< FragmentSource >	vizDiamondScalarFragment ()
std::shared_ptr< VertexSource >	vizCloudColorVertex ()
std::shared_ptr< FragmentSource >	vizCloudColorFragment ()
std::shared_ptr< VertexSource >	vizCloudScalarVertex ()
std::shared_ptr< FragmentSource >	vizCloudScalarFragment ()
std::shared_ptr< VertexSource >	vizCloudColorOffsetVertex ()
std::shared_ptr< VertexSource >	vizCloudScalarOffsetVertex ()
std::shared_ptr< VertexSource >	vizAnimLineColorVertex ()
std::shared_ptr< FragmentSource >	vizAnimLineColorFragment ()
std::shared_ptr< VertexSource >	vizAnimLineScalarVertex ()
std::shared_ptr< FragmentSource >	vizAnimLineScalarFragment ()
std::shared_ptr< GeometrySource >	vizAnimWidthColorGeometry ()
std::shared_ptr< FragmentSource >	vizAnimWidthColorFragment ()
std::shared_ptr< GeometrySource >	vizAnimWidthScalarGeometry ()
std::shared_ptr< FragmentSource >	vizAnimWidthScalarFragment ()
std::shared_ptr< GeometrySource >	vizAnimRibbonColorGeometry ()
std::shared_ptr< FragmentSource >	vizAnimRibbonColorFragment ()
std::shared_ptr< GeometrySource >	vizAnimRibbonScalarGeometry ()
std::shared_ptr< FragmentSource >	vizAnimRibbonScalarFragment ()
std::shared_ptr< GeometrySource >	vizAnimCylinderColorGeometry ()
std::shared_ptr< FragmentSource >	vizAnimCylinderColorFragment ()
std::shared_ptr< GeometrySource >	vizAnimCylinderScalarGeometry ()
std::shared_ptr< FragmentSource >	vizAnimCylinderScalarFragment ()
std::shared_ptr< VertexSource >	vizInstanceColorVertex ()
std::shared_ptr< VertexSource >	vizInstanceScalarVertex ()
std::shared_ptr< VertexSource >	vizInstanceUnlightVertex ()
std::shared_ptr< FragmentSource >	vizInstanceFragment ()
std::shared_ptr< VertexSource >	vizPtclSphereColorVertex ()
std::shared_ptr< FragmentSource >	vizPtclSphereColorFragment ()
std::shared_ptr< VertexSource >	vizPtclSphereScalarVertex ()
std::shared_ptr< FragmentSource >	vizPtclSphereScalarFragment ()
std::shared_ptr< VertexSource >	vizPtclFixedSphereColorVertex ()
std::shared_ptr< VertexSource >	vizPtclFixedSphereScalarVertex ()
std::shared_ptr< FragmentSource >	vizAnimMeteorColorFragment ()
std::shared_ptr< FragmentSource >	vizAnimMeteorScalarFragment ()
std::shared_ptr< VertexSource >	vizArrowColorVertex ()
std::shared_ptr< VertexSource >	vizArrowScalarVertex ()
std::shared_ptr< VertexSource >	vizFixedArrowColorVertex ()
std::shared_ptr< VertexSource >	vizFixedArrowScalarVertex ()
std::shared_ptr< Depth >	vizOpaqueDepth ()
std::shared_ptr< Depth >	vizTransparentDepth ()
std::shared_ptr< PolygonOffset >	vizOpaquePolygonOffset ()
std::shared_ptr< PolygonOffset >	vizTransparentPolygonOffset ()
std::shared_ptr< Culling >	vizGlyphCulling ()
std::shared_ptr< Point >	vizSpherePoint ()
std::shared_ptr< Point >	vizPointSprites ()
std::shared_ptr< Blend >	vizTransparentBlend ()
std::shared_ptr< Sampler >	vizScalarSampler ()

Typedef Documentation

ArrayBufferPtr

using cil::ArrayBufferPtr = std::shared_ptr<ArrayBuffer>

ArrayIndicesPtr

using cil::ArrayIndicesPtr = std::shared_ptr<ArrayIndices>

AttributesOverwriter

typedef std::function<void(Attributes&, int, int)> cil::AttributesOverwriter

AttributesOverwriterPtr

typedef std::shared_ptr<AttributesOverwriter> cil::AttributesOverwriterPtr

BackgroundPtr

using cil::BackgroundPtr = std::shared_ptr<Background>

bbox

using cil::bbox = BoundingBox

BlendPtr

using cil::BlendPtr = std::shared_ptr<Blend>

BoundingBoxPtr

using cil::BoundingBoxPtr = std::shared_ptr<BoundingBox>

box2

using cil::box2 = Box2f

Box2fPtr

using cil::Box2fPtr = std::shared_ptr<Box2f>

Box2iPtr

using cil::Box2iPtr = std::shared_ptr<Box2i>

box3

using cil::box3 = Box3f

Box3fPtr

using cil::Box3fPtr = std::shared_ptr<Box3f>

Box3iPtr

using cil::Box3iPtr = std::shared_ptr<Box3i>

CameraPtr

using cil::CameraPtr = std::shared_ptr<Camera>

ClipPtr

using cil::ClipPtr = std::shared_ptr<Clip>

clr3

using cil::clr3 = Color3f

clr3ub

using cil::clr3ub = Color3ub

clr4

using cil::clr4 = Color4f

clr4ub

using cil::clr4ub = Color4ub

Color3fPtr

using cil::Color3fPtr = std::shared_ptr<Color3f>

Color3ubPtr

using cil::Color3ubPtr = std::shared_ptr<Color3ub>

Color4fPtr

using cil::Color4fPtr = std::shared_ptr<Color4f>

Color4ubPtr

using cil::Color4ubPtr = std::shared_ptr<Color4ub>

ColorMaskPtr

using cil::ColorMaskPtr = std::shared_ptr<ColorMask>

ContourPtr

using cil::ContourPtr = std::shared_ptr<Contour>

CullingPtr

using cil::CullingPtr = std::shared_ptr<Culling>

CutterPtr

using cil::CutterPtr = std::shared_ptr<Cutter>

DataModelPtr

using cil::DataModelPtr = std::shared_ptr<DataModel>

DataModelPtrArray

using cil::DataModelPtrArray = std::vector<DataModelPtr>

DataPartPtr

using cil::DataPartPtr = std::shared_ptr<DataPart>

DataPartPtrArray

using cil::DataPartPtrArray = std::vector<DataPartPtr>

DataScalar

using cil::DataScalar = MinMax

DataSolutionPtr

using cil::DataSolutionPtr = std::shared_ptr<DataSolution>

DataVector

using cil::DataVector = MinMax

DepthPtr

using cil::DepthPtr = std::shared_ptr<Depth>

ElementIndicesPtr

using cil::ElementIndicesPtr = std::shared_ptr<ElementIndices>

f32array

using cil::f32array = Float32Array

f64array

using cil::f64array = Float64Array

FilterFunction

using cil::FilterFunction = std::function<std::shared_ptr<Pass>(const std::shared_ptr<Pass>&)>

FilterPtr

using cil::FilterPtr = std::shared_ptr<Filter>

FilterPtrArray

using cil::FilterPtrArray = std::vector<FilterPtr>

Float32ArrayPtr

using cil::Float32ArrayPtr = std::shared_ptr<Float32Array>

Float64ArrayPtr

using cil::Float64ArrayPtr = std::shared_ptr<Float64Array>

frag

using cil::frag = FragmentSource

FragmentSourcePtr

using cil::FragmentSourcePtr = std::shared_ptr<FragmentSource>

FringeSurfacePtr

using cil::FringeSurfacePtr = std::shared_ptr<FringeSurface>

geom

using cil::geom = GeometrySource

GeometryPtr

using cil::GeometryPtr = std::shared_ptr<Geometry>

GeometrySourcePtr

using cil::GeometrySourcePtr = std::shared_ptr<GeometrySource>

i16array

using cil::i16array = Int16Array

i32array

using cil::i32array = Int32Array

i8array

using cil::i8array = Int8Array

ibox2

using cil::ibox2 = Box2i

ibox3

using cil::ibox3 = Box3i

image2d

using cil::image2d = Image2D

Image2DPtr

using cil::Image2DPtr = std::shared_ptr<Image2D>

imageBuf

using cil::imageBuf = ImageBuffer

ImageBufferPtr

using cil::ImageBufferPtr = std::shared_ptr<ImageBuffer>

imageCube

using cil::imageCube = ImageCube

ImageCubePtr

using cil::ImageCubePtr = std::shared_ptr<ImageCube>

ImagePtr

using cil::ImagePtr = std::shared_ptr<Image>

IndicesPtr

using cil::IndicesPtr = std::shared_ptr<Indices>

Int16ArrayPtr

using cil::Int16ArrayPtr = std::shared_ptr<Int16Array>

Int32ArrayPtr

using cil::Int32ArrayPtr = std::shared_ptr<Int32Array>

Int8ArrayPtr

using cil::Int8ArrayPtr = std::shared_ptr<Int8Array>

integer

using cil::integer = Integer

IntegerPtr

using cil::IntegerPtr = std::shared_ptr<Integer>

ivec2

using cil::ivec2 = Vector2i

ivec3

using cil::ivec3 = Vector3i

ivec4

using cil::ivec4 = Vector4i

LegoPtr

using cil::LegoPtr = std::shared_ptr<Lego>

LinePtr

using cil::LinePtr = std::shared_ptr<Line>

mat2

using cil::mat2 = Matrix2f

mat3

using cil::mat3 = Matrix3f

mat4

using cil::mat4 = Matrix4f

MaterialPtr

using cil::MaterialPtr = std::shared_ptr<Material>

Matrix2fPtr

using cil::Matrix2fPtr = std::shared_ptr<Matrix2f>

Matrix3fPtr

using cil::Matrix3fPtr = std::shared_ptr<Matrix3f>

Matrix4fPtr

using cil::Matrix4fPtr = std::shared_ptr<Matrix4f>

MeshPtr

using cil::MeshPtr = std::shared_ptr<Mesh>

minmax

using cil::minmax = MinMax

MinMaxPtr

using cil::MinMaxPtr = std::shared_ptr<MinMax>

NodePtr

using cil::NodePtr = std::shared_ptr<Node>

PassPtr

using cil::PassPtr = std::shared_ptr<Pass>

plane

using cil::plane = Plane

PlanePtr

using cil::PlanePtr = std::shared_ptr<Plane>

PointCloudPtr

using cil::PointCloudPtr = std::shared_ptr<PointCloud>

PointPtr

using cil::PointPtr = std::shared_ptr<Point>

PolygonOffsetPtr

using cil::PolygonOffsetPtr = std::shared_ptr<PolygonOffset>

PolygonPtr

using cil::PolygonPtr = std::shared_ptr<Polygon>

PolygonSurfacePtr

using cil::PolygonSurfacePtr = std::shared_ptr<PolygonSurface>

PrimitivePtr

using cil::PrimitivePtr = std::shared_ptr<Primitive>

ProbePtr

using cil::ProbePtr = std::shared_ptr<Probe>

ProgramPtr

using cil::ProgramPtr = std::shared_ptr<Program>

quat

using cil::quat = Quaternion

QuaternionPtr

using cil::QuaternionPtr = std::shared_ptr<Quaternion>

QueryPtr

using cil::QueryPtr = std::shared_ptr<Query>

ray

using cil::ray = Ray

RayPtr

using cil::RayPtr = std::shared_ptr<Ray>

real

using cil::real = Real

RealPtr

using cil::RealPtr = std::shared_ptr<Real>

RibbonPtr

using cil::RibbonPtr = std::shared_ptr<Ribbon>

SamplerPtr

using cil::SamplerPtr = std::shared_ptr<Sampler>

ScenePtr

using cil::ScenePtr = std::shared_ptr<Scene>

ScissorPtr

using cil::ScissorPtr = std::shared_ptr<Scissor>

SlicePtr

using cil::SlicePtr = std::shared_ptr<Slice>

SourcePtr

using cil::SourcePtr = std::shared_ptr<Source>

StatePtr

using cil::StatePtr = std::shared_ptr<State>

StencilPtr

using cil::StencilPtr = std::shared_ptr<Stencil>

StreamSurfacePtr

using cil::StreamSurfacePtr = std::shared_ptr<StreamSurface>

StreamTracerPtr

using cil::StreamTracerPtr = std::shared_ptr<StreamTracer>

TargetPtr

using cil::TargetPtr = std::shared_ptr<Target>

TexturePtr

using cil::TexturePtr = std::shared_ptr<Texture>

ThresholdPtr

using cil::ThresholdPtr = std::shared_ptr<Threshold>

TubePtr

using cil::TubePtr = std::shared_ptr<Tube>

u16array

using cil::u16array = Uint16Array

u32array

using cil::u32array = Uint32Array

u8array

using cil::u8array = Uint8Array

Uint16ArrayPtr

using cil::Uint16ArrayPtr = std::shared_ptr<Uint16Array>

Uint32ArrayPtr

using cil::Uint32ArrayPtr = std::shared_ptr<Uint32Array>

Uint8ArrayPtr

using cil::Uint8ArrayPtr = std::shared_ptr<Uint8Array>

VariantPtr

using cil::VariantPtr = std::shared_ptr<Variant>

vec2

using cil::vec2 = Vector2f

vec3

using cil::vec3 = Vector3f

vec4

using cil::vec4 = Vector4f

Vector2fPtr

using cil::Vector2fPtr = std::shared_ptr<Vector2f>

Vector2iPtr

using cil::Vector2iPtr = std::shared_ptr<Vector2i>

Vector3fPtr

using cil::Vector3fPtr = std::shared_ptr<Vector3f>

Vector3iPtr

using cil::Vector3iPtr = std::shared_ptr<Vector3i>

Vector4fPtr

using cil::Vector4fPtr = std::shared_ptr<Vector4f>

Vector4iPtr

using cil::Vector4iPtr = std::shared_ptr<Vector4i>

vert

using cil::vert = VertexSource

VertexSourcePtr

using cil::VertexSourcePtr = std::shared_ptr<VertexSource>

VerticesPtr

using cil::VerticesPtr = std::shared_ptr<Vertices>

VizBodyPtr

using cil::VizBodyPtr = std::shared_ptr<VizBody>

VizBodyPtrArray

using cil::VizBodyPtrArray = std::vector<VizBodyPtr>

VizGeometryPtr

using cil::VizGeometryPtr = std::shared_ptr<VizGeometry>

VizModelPtr

using cil::VizModelPtr = std::shared_ptr<VizModel>

VizModelPtrMap

using cil::VizModelPtrMap = std::map<int, VizModelPtr>

VizPartPtr

using cil::VizPartPtr = std::shared_ptr<VizPart>

VizPartPtrMap

using cil::VizPartPtrMap = std::map<int, VizPartPtr>

VizResultPtr

using cil::VizResultPtr = std::shared_ptr<VizResult>

VizScalarPtr

using cil::VizScalarPtr = std::shared_ptr<VizScalar>

VizScalarPtrMap

using cil::VizScalarPtrMap = std::map<std::string, VizScalarPtr>

VizSolutionPtr

using cil::VizSolutionPtr = std::shared_ptr<VizSolution>

VizVectorPtr

using cil::VizVectorPtr = std::shared_ptr<VizVector>

VizVectorPtrMap

using cil::VizVectorPtrMap = std::map<std::string, VizVectorPtr>

Enumeration Type Documentation

LineStyle

enum class cil::LineStyle

strong

Enumerator
Solid
Dash
Dot
DashDot
DashDotDot

SelectorUpdateMode

enum class cil::SelectorUpdateMode

strong

Enumerator
None
View
Entity
All

Function Documentation

_2planeClipping() [1/2]

std::shared_ptr< TwoPlaneClipping > cil::_2planeClipping

(

)

_2planeClipping() [2/2]

std::shared_ptr< TwoPlaneClipping > cil::_2planeClipping	(	const std::shared_ptr< Vector3f > &	origin1,
		const std::shared_ptr< Vector3f > &	normal1,
		const std::shared_ptr< Vector3f > &	origin2,
		const std::shared_ptr< Vector3f > &	normal2 )

_aliceblue()

std::shared_ptr< Color3f > cil::_aliceblue

(

)

_antiquewhite()

std::shared_ptr< Color3f > cil::_antiquewhite

(

)

_aqua()

std::shared_ptr< Color3f > cil::_aqua

(

)

_aquamarine()

std::shared_ptr< Color3f > cil::_aquamarine

(

)

_arcHandler()

std::shared_ptr< ArcHandler > cil::_arcHandler

(

const std::shared_ptr< Matrix4f > &

matrix

)

_arrayIndices()

ArrayIndicesPtr cil::_arrayIndices	(	Indices::Mode	mode,
		int	count,
		int	first = 0,
		int	primCount = 0 )

_arrowLocator()

std::shared_ptr< ArrowLocator > cil::_arrowLocator

(

)

_axialTransformPath() [1/2]

std::shared_ptr< AxialTransformPath > cil::_axialTransformPath

(

)

_axialTransformPath() [2/2]

std::shared_ptr< AxialTransformPath > cil::_axialTransformPath	(	const std::shared_ptr< Vector3f > &	origin,
		const std::shared_ptr< Vector3f > &	direction )

_axis()

std::shared_ptr< Axis > cil::_axis	(	const std::shared_ptr< Vector2i > &	coordinate,
		const std::shared_ptr< Vector2i > &	backgroundSize )

_azure()

std::shared_ptr< Color3f > cil::_azure

(

)

_background()

BackgroundPtr cil::_background	(	const Vector2iPtr &	size,
		const Color4fPtr &	colorMask = nullptr,
		const RealPtr &	depthMask = nullptr,
		const IntegerPtr &	stencilMask = nullptr,
		const Vector2iPtr &	coordinate = _ivec2() )

_bbox() [1/4]

BoundingBoxPtr cil::_bbox

(

)

_bbox() [2/4]

BoundingBoxPtr cil::_bbox

(

const BoundingBox &

other

)

_bbox() [3/4]

BoundingBoxPtr cil::_bbox	(	const Vector3f &	min,
		const Vector3f &	max )

_bbox() [4/4]

BoundingBoxPtr cil::_bbox	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax,
		float	zmin,
		float	zmax )

_beige()

std::shared_ptr< Color3f > cil::_beige

(

)

_bisque()

std::shared_ptr< Color3f > cil::_bisque

(

)

_black()

std::shared_ptr< Color3f > cil::_black

(

)

_blanchedalmond()

std::shared_ptr< Color3f > cil::_blanchedalmond

(

)

_blend()

BlendPtr cil::_blend	(	bool	enabled = false,
		Blend::Function	srcFunc = Blend::Function::SRC_ALPHA,
		Blend::Function	dstFunc = Blend::Function::ONE_MINUS_SRC_ALPHA,
		Blend::Equation	equation = Blend::Equation::FUNC_ADD )

_blend_transparent()

std::shared_ptr< Blend > cil::_blend_transparent

(

)

_blue()

std::shared_ptr< Color3f > cil::_blue

(

)

_blueviolet()

std::shared_ptr< Color3f > cil::_blueviolet

(

)

_bottomBoxLocator()

std::shared_ptr< BottomBoxLocator > cil::_bottomBoxLocator

(

)

_bottomCylinderLocator()

std::shared_ptr< BottomCylinderLocator > cil::_bottomCylinderLocator

(

)

_box2f() [1/4]

Box2fPtr cil::_box2f

(

)

_box2f() [2/4]

Box2fPtr cil::_box2f

(

const Box2f &

other

)

_box2f() [3/4]

Box2fPtr cil::_box2f	(	const Vector2f &	min,
		const Vector2f &	max )

_box2f() [4/4]

Box2fPtr cil::_box2f	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax )

_box2i() [1/4]

Box2iPtr cil::_box2i

(

)

_box2i() [2/4]

Box2iPtr cil::_box2i

(

const Box2i &

other

)

_box2i() [3/4]

Box2iPtr cil::_box2i	(	const Vector2i &	min,
		const Vector2i &	max )

_box2i() [4/4]

Box2iPtr cil::_box2i	(	int	xmin,
		int	xmax,
		int	ymin,
		int	ymax )

_box3f() [1/4]

Box3fPtr cil::_box3f

(

)

_box3f() [2/4]

Box3fPtr cil::_box3f

(

const Box3f &

other

)

_box3f() [3/4]

Box3fPtr cil::_box3f	(	const Vector3f &	min,
		const Vector3f &	max )

_box3f() [4/4]

Box3fPtr cil::_box3f	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax,
		float	zmin,
		float	zmax )

_box3i() [1/4]

Box3iPtr cil::_box3i

(

)

_box3i() [2/4]

Box3iPtr cil::_box3i

(

const Box3i &

other

)

_box3i() [3/4]

Box3iPtr cil::_box3i	(	const Vector3i &	min,
		const Vector3i &	max )

_box3i() [4/4]

Box3iPtr cil::_box3i	(	int	xmin,
		int	xmax,
		int	ymin,
		int	ymax,
		int	zmin,
		int	zmax )

_boxBlur()

std::shared_ptr< Pass > cil::_boxBlur

(

const std::shared_ptr< Pass > &

input

)

_boxLocator()

std::shared_ptr< BoxLocator > cil::_boxLocator

(

)

_brown()

std::shared_ptr< Color3f > cil::_brown

(

)

_burlywood()

std::shared_ptr< Color3f > cil::_burlywood

(

)

_cadetblue()

std::shared_ptr< Color3f > cil::_cadetblue

(

)

_camera()

CameraPtr cil::_camera	(	const Matrix4fPtr &	viewMatrix = _mat4(),
		const Matrix4fPtr &	projectionMatrix = _mat4(),
		const Vector3fPtr &	orbitPoint = _vec3() )

_chartreuse()

std::shared_ptr< Color3f > cil::_chartreuse

(

)

_chocolate()

std::shared_ptr< Color3f > cil::_chocolate

(

)

_clipper()

std::shared_ptr< Clipper > cil::_clipper

(

)

_clr3() [1/6]

Color3fPtr cil::_clr3

(

)

_clr3() [2/6]

Color3fPtr cil::_clr3

(

const Color3f &

other

)

_clr3() [3/6]

Color3fPtr cil::_clr3

(

const Color3ub &

other

)

_clr3() [4/6]

Color3fPtr cil::_clr3

(

const Color4f &

other

)

_clr3() [5/6]

Color3fPtr cil::_clr3

(

const Color4ub &

other

)

_clr3() [6/6]

Color3fPtr cil::_clr3	(	float	r,
		float	g,
		float	b )

_clr3ub() [1/6]

Color3ubPtr cil::_clr3ub

(

)

_clr3ub() [2/6]

Color3ubPtr cil::_clr3ub

(

const Color3f &

other

)

_clr3ub() [3/6]

Color3ubPtr cil::_clr3ub

(

const Color3ub &

other

)

_clr3ub() [4/6]

Color3ubPtr cil::_clr3ub

(

const Color4f &

other

)

_clr3ub() [5/6]

Color3ubPtr cil::_clr3ub

(

const Color4ub &

other

)

_clr3ub() [6/6]

Color3ubPtr cil::_clr3ub	(	unsigned char	r,
		unsigned char	g,
		unsigned char	b )

_clr4() [1/6]

Color4fPtr cil::_clr4

(

)

_clr4() [2/6]

Color4fPtr cil::_clr4

(

const Color3f &

other

)

_clr4() [3/6]

Color4fPtr cil::_clr4

(

const Color3ub &

other

)

_clr4() [4/6]

Color4fPtr cil::_clr4

(

const Color4f &

other

)

_clr4() [5/6]

Color4fPtr cil::_clr4

(

const Color4ub &

other

)

_clr4() [6/6]

Color4fPtr cil::_clr4	(	float	r,
		float	g,
		float	b,
		float	a )

_clr4ub() [1/6]

Color4ubPtr cil::_clr4ub

(

)

_clr4ub() [2/6]

Color4ubPtr cil::_clr4ub

(

const Color3f &

other

)

_clr4ub() [3/6]

Color4ubPtr cil::_clr4ub

(

const Color3ub &

other

)

_clr4ub() [4/6]

Color4ubPtr cil::_clr4ub

(

const Color4f &

other

)

_clr4ub() [5/6]

Color4ubPtr cil::_clr4ub

(

const Color4ub &

other

)

_clr4ub() [6/6]

Color4ubPtr cil::_clr4ub	(	unsigned char	r,
		unsigned char	g,
		unsigned char	b,
		unsigned char	a )

_colorBuf()

ImageBufferPtr cil::_colorBuf

(

)

_colorGenerator()

std::shared_ptr< ColorGenerator > cil::_colorGenerator

(

float

hue = 0

)

_colorMask()

ColorMaskPtr cil::_colorMask	(	bool	red = true,
		bool	green = true,
		bool	blue = true,
		bool	alpha = true )

_compositeLocator()

std::shared_ptr< CompositeLocator > cil::_compositeLocator	(	const std::shared_ptr< Locator > &	origin,
		const std::shared_ptr< ShapeLocator > &	shape )

_coral()

std::shared_ptr< Color3f > cil::_coral

(

)

_cornerViewCube()

std::shared_ptr< CornerViewCube > cil::_cornerViewCube	(	const std::shared_ptr< Renderer > &	renderer,
		const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< Vector2i > &	coordinate,
		const std::shared_ptr< Vector2i > &	backgroundSize,
		const std::shared_ptr< Vector2i > &	windowSize )

_cornflowerblue()

std::shared_ptr< Color3f > cil::_cornflowerblue

(

)

_cornsilk()

std::shared_ptr< Color3f > cil::_cornsilk

(

)

_crimson()

std::shared_ptr< Color3f > cil::_crimson

(

)

_culling()

CullingPtr cil::_culling	(	bool	enabled = false,
		Culling::Face	face = Culling::Face::CCW,
		Culling::Mode	mode = Culling::Mode::BACK )

_culling_glyph()

std::shared_ptr< Culling > cil::_culling_glyph

(

)

_cyan()

std::shared_ptr< Color3f > cil::_cyan

(

)

_cylinderLocator()

std::shared_ptr< CylinderLocator > cil::_cylinderLocator

(

)

_darkblue()

std::shared_ptr< Color3f > cil::_darkblue

(

)

_darkcyan()

std::shared_ptr< Color3f > cil::_darkcyan

(

)

_darkgoldenrod()

std::shared_ptr< Color3f > cil::_darkgoldenrod

(

)

_darkgray()

std::shared_ptr< Color3f > cil::_darkgray

(

)

_darkgreen()

std::shared_ptr< Color3f > cil::_darkgreen

(

)

_darkgrey()

std::shared_ptr< Color3f > cil::_darkgrey

(

)

_darkkhaki()

std::shared_ptr< Color3f > cil::_darkkhaki

(

)

_darkmagenta()

std::shared_ptr< Color3f > cil::_darkmagenta

(

)

_darkolivegreen()

std::shared_ptr< Color3f > cil::_darkolivegreen

(

)

_darkorange()

std::shared_ptr< Color3f > cil::_darkorange

(

)

_darkorchid()

std::shared_ptr< Color3f > cil::_darkorchid

(

)

_darkred()

std::shared_ptr< Color3f > cil::_darkred

(

)

_darksalmon()

std::shared_ptr< Color3f > cil::_darksalmon

(

)

_darkseagreen()

std::shared_ptr< Color3f > cil::_darkseagreen

(

)

_darkslateblue()

std::shared_ptr< Color3f > cil::_darkslateblue

(

)

_darkslategray()

std::shared_ptr< Color3f > cil::_darkslategray

(

)

_darkslategrey()

std::shared_ptr< Color3f > cil::_darkslategrey

(

)

_darkturquoise()

std::shared_ptr< Color3f > cil::_darkturquoise

(

)

_darkviolet()

std::shared_ptr< Color3f > cil::_darkviolet

(

)

_decals()

std::shared_ptr< Decals > cil::_decals

(

)

_deeppink()

std::shared_ptr< Color3f > cil::_deeppink

(

)

_deepskyblue()

std::shared_ptr< Color3f > cil::_deepskyblue

(

)

_depth()

DepthPtr cil::_depth	(	bool	enabled = false,
		Depth::Function	func = Depth::Function::LESS,
		bool	writeMask = true )

_depth_opaque()

std::shared_ptr< Depth > cil::_depth_opaque

(

)

_depth_transparent()

std::shared_ptr< Depth > cil::_depth_transparent

(

)

_dilate()

std::shared_ptr< Pass > cil::_dilate

(

const std::shared_ptr< Pass > &

input

)

_dimgray()

std::shared_ptr< Color3f > cil::_dimgray

(

)

_dimgrey()

std::shared_ptr< Color3f > cil::_dimgrey

(

)

_diskLocator()

std::shared_ptr< DiskLocator > cil::_diskLocator

(

)

_dodgerblue()

std::shared_ptr< Color3f > cil::_dodgerblue

(

)

_edgeDetection()

std::shared_ptr< Pass > cil::_edgeDetection

(

const std::shared_ptr< Pass > &

input

)

_edgeEnhancement()

std::shared_ptr< Pass > cil::_edgeEnhancement

(

const std::shared_ptr< Pass > &

input

)

_edgeSelector()

template<typename T >

std::shared_ptr< EdgeSelector< T > > cil::_edgeSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options,
		bool	buffered = true )

_elementIndices() [1/3]

ElementIndicesPtr cil::_elementIndices	(	Indices::Mode	mode,
		const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_elementIndices() [2/3]

ElementIndicesPtr cil::_elementIndices	(	Indices::Mode	mode,
		const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_elementIndices() [3/3]

ElementIndicesPtr cil::_elementIndices	(	Indices::Mode	mode,
		const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_emboss()

std::shared_ptr< Pass > cil::_emboss

(

const std::shared_ptr< Pass > &

input

)

_erode()

std::shared_ptr< Pass > cil::_erode

(

const std::shared_ptr< Pass > &

input

)

_exploder()

std::shared_ptr< Exploder > cil::_exploder

(

)

_f32array() [1/2]

Float32ArrayPtr cil::_f32array

(

const std::initializer_list< float > &

array

)

_f32array() [2/2]

Float32ArrayPtr cil::_f32array	(	int	size = 0,
		float *	data = nullptr,
		bool	copy = true )

_f64array() [1/2]

Float64ArrayPtr cil::_f64array

(

const std::initializer_list< double > &

array

)

_f64array() [2/2]

Float64ArrayPtr cil::_f64array	(	int	size = 0,
		double *	data = nullptr,
		bool	copy = true )

_faceSelector()

template<typename T >

std::shared_ptr< FaceSelector< T > > cil::_faceSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options,
		bool	buffered = true )

_filterImage()

std::shared_ptr< std::vector< std::shared_ptr< Pass > > > cil::_filterImage	(	const std::shared_ptr< Pass > &	input,
		const std::vector< FilterFunction > &	filters )

_firebrick()

std::shared_ptr< Color3f > cil::_firebrick

(

)

_floralwhite()

std::shared_ptr< Color3f > cil::_floralwhite

(

)

_forestgreen()

std::shared_ptr< Color3f > cil::_forestgreen

(

)

_frag()

FragmentSourcePtr cil::_frag

(

const std::string &

text

)

_fragment_cloud_color()

std::shared_ptr< FragmentSource > cil::_fragment_cloud_color

(

)

_fragment_cloud_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_cloud_scalar

(

)

_fragment_cylinder_color()

std::shared_ptr< FragmentSource > cil::_fragment_cylinder_color

(

)

_fragment_cylinder_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_cylinder_scalar

(

)

_fragment_flat_color()

std::shared_ptr< FragmentSource > cil::_fragment_flat_color

(

)

_fragment_forward_cylinder_color()

std::shared_ptr< FragmentSource > cil::_fragment_forward_cylinder_color

(

)

_fragment_forward_cylinder_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_forward_cylinder_scalar

(

)

_fragment_forward_fixed_sphere_color()

std::shared_ptr< FragmentSource > cil::_fragment_forward_fixed_sphere_color

(

)

_fragment_forward_fixed_sphere_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_forward_fixed_sphere_scalar

(

)

_fragment_forward_ribbon_color()

std::shared_ptr< FragmentSource > cil::_fragment_forward_ribbon_color

(

)

_fragment_forward_ribbon_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_forward_ribbon_scalar

(

)

_fragment_forward_sphere_color()

std::shared_ptr< FragmentSource > cil::_fragment_forward_sphere_color

(

)

_fragment_forward_sphere_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_forward_sphere_scalar

(

)

_fragment_gouraud_color()

std::shared_ptr< FragmentSource > cil::_fragment_gouraud_color

(

)

_fragment_gouraud_cube_texture()

std::shared_ptr< FragmentSource > cil::_fragment_gouraud_cube_texture

(

)

_fragment_gouraud_texture()

std::shared_ptr< FragmentSource > cil::_fragment_gouraud_texture

(

)

_fragment_head_light_color()

std::shared_ptr< FragmentSource > cil::_fragment_head_light_color

(

)

_fragment_head_light_cube_texture()

std::shared_ptr< FragmentSource > cil::_fragment_head_light_cube_texture

(

)

_fragment_head_light_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_head_light_scalar

(

)

_fragment_head_light_texture()

std::shared_ptr< FragmentSource > cil::_fragment_head_light_texture

(

)

_fragment_line_dash()

std::shared_ptr< FragmentSource > cil::_fragment_line_dash

(

)

_fragment_line_dashdot()

std::shared_ptr< FragmentSource > cil::_fragment_line_dashdot

(

)

_fragment_line_dashdotdot()

std::shared_ptr< FragmentSource > cil::_fragment_line_dashdotdot

(

)

_fragment_line_dot()

std::shared_ptr< FragmentSource > cil::_fragment_line_dot

(

)

_fragment_line_solid()

std::shared_ptr< FragmentSource > cil::_fragment_line_solid

(

)

_fragment_meteor_cylinder_color()

std::shared_ptr< FragmentSource > cil::_fragment_meteor_cylinder_color

(

)

_fragment_meteor_cylinder_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_meteor_cylinder_scalar

(

)

_fragment_meteor_line_color()

std::shared_ptr< FragmentSource > cil::_fragment_meteor_line_color

(

)

_fragment_meteor_line_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_meteor_line_scalar

(

)

_fragment_phong_color()

std::shared_ptr< FragmentSource > cil::_fragment_phong_color

(

)

_fragment_phong_cube_texture()

std::shared_ptr< FragmentSource > cil::_fragment_phong_cube_texture

(

)

_fragment_phong_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_phong_scalar

(

)

_fragment_phong_texture()

std::shared_ptr< FragmentSource > cil::_fragment_phong_texture

(

)

_fragment_point_sprites_circle()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_circle

(

)

_fragment_point_sprites_disc()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_disc

(

)

_fragment_point_sprites_grid()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_grid

(

)

_fragment_point_sprites_icon()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_icon

(

)

_fragment_point_sprites_rose()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_rose

(

)

_fragment_point_sprites_sphere()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_sphere

(

)

_fragment_point_sprites_spiral()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_spiral

(

)

_fragment_point_sprites_square()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_square

(

)

_fragment_point_sprites_star()

std::shared_ptr< FragmentSource > cil::_fragment_point_sprites_star

(

)

_fragment_ribbon_color()

std::shared_ptr< FragmentSource > cil::_fragment_ribbon_color

(

)

_fragment_ribbon_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_ribbon_scalar

(

)

_fragment_scale_color()

std::shared_ptr< FragmentSource > cil::_fragment_scale_color

(

)

_fragment_scale_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_scale_scalar

(

)

_fragment_sphere_color()

std::shared_ptr< FragmentSource > cil::_fragment_sphere_color

(

)

_fragment_sphere_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_sphere_scalar

(

)

_fragment_strip_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_strip_scalar

(

)

_fragment_transparent_color()

std::shared_ptr< FragmentSource > cil::_fragment_transparent_color

(

)

_fragment_transparent_scalar()

std::shared_ptr< FragmentSource > cil::_fragment_transparent_scalar

(

)

_fragment_unlight_color()

std::shared_ptr< FragmentSource > cil::_fragment_unlight_color

(

)

_fragment_unlight_color_transparent()

std::shared_ptr< FragmentSource > cil::_fragment_unlight_color_transparent

(

)

_fragment_unlight_cube_texture()

std::shared_ptr< FragmentSource > cil::_fragment_unlight_cube_texture

(

)

_fragment_unlight_texture()

std::shared_ptr< FragmentSource > cil::_fragment_unlight_texture

(

)

_fragment_vertex_color()

std::shared_ptr< FragmentSource > cil::_fragment_vertex_color

(

)

_fuchsia()

std::shared_ptr< Color3f > cil::_fuchsia

(

)

_fullViewCube()

std::shared_ptr< FullViewCube > cil::_fullViewCube	(	const std::shared_ptr< Renderer > &	renderer,
		const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< Vector2i > &	coordinate,
		const std::shared_ptr< Vector2i > &	backgroundSize,
		const std::shared_ptr< Vector2i > &	windowSize )

_gainsboro()

std::shared_ptr< Color3f > cil::_gainsboro

(

)

_gaussianBlur()

std::shared_ptr< Pass > cil::_gaussianBlur

(

const std::shared_ptr< Pass > &

input

)

_geom()

GeometrySourcePtr cil::_geom

(

const std::string &

text

)

_geometry() [1/3]

GeometryPtr cil::_geometry	(	const IndicesPtr &	indices,
		const BoundingBoxPtr &	boundingBox = nullptr )

_geometry() [2/3]

GeometryPtr cil::_geometry	(	const std::shared_ptr< std::map< std::string, VerticesPtr > > &	verticesSet = _verticesSet(),
		const IndicesPtr &	indices = nullptr,
		const BoundingBoxPtr &	boundingBox = nullptr )

_geometry() [3/3]

GeometryPtr cil::_geometry	(	std::map< std::string, VerticesPtr >	verticesSet,
		const IndicesPtr &	indices = nullptr,
		const BoundingBoxPtr &	boundingBox = nullptr )

_geometry_arrow()

std::shared_ptr< Geometry > cil::_geometry_arrow

(

)

_geometry_capsule()

std::shared_ptr< Geometry > cil::_geometry_capsule	(	const float	radius = 1.0,
		const float	height = 2.0,
		const int	slices = 24,
		const int	stacks = 24 )

_geometry_cone()

std::shared_ptr< Geometry > cil::_geometry_cone	(	const float	radius = 1.0,
		const float	height = 1.0,
		const int	slices = 36 )

_geometry_cube()

std::shared_ptr< Geometry > cil::_geometry_cube	(	const Vector3f &	min = vec3(-1, -1, -1),
		const Vector3f &	max = vec3(1, 1, 1) )

_geometry_cube_outline()

std::shared_ptr< Geometry > cil::_geometry_cube_outline	(	const Vector3f &	min = vec3(-1, -1, -1),
		const Vector3f &	max = vec3(1, 1, 1) )

_geometry_cylinder()

std::shared_ptr< Geometry > cil::_geometry_cylinder	(	const float	radius = 1.0,
		const float	height = 1.0,
		const int	slices = 36 )

_geometry_cylinder_color()

std::shared_ptr< GeometrySource > cil::_geometry_cylinder_color

(

)

_geometry_cylinder_scalar()

std::shared_ptr< GeometrySource > cil::_geometry_cylinder_scalar

(

)

_geometry_decal()

std::shared_ptr< Geometry > cil::_geometry_decal

(

)

_geometry_decalBackground()

std::shared_ptr< Geometry > cil::_geometry_decalBackground

(

)

_geometry_disk()

std::shared_ptr< Geometry > cil::_geometry_disk	(	const float	radius = 1,
		const int	slices = 36 )

_geometry_forward_cylinder_color()

std::shared_ptr< GeometrySource > cil::_geometry_forward_cylinder_color

(

)

_geometry_forward_cylinder_scalar()

std::shared_ptr< GeometrySource > cil::_geometry_forward_cylinder_scalar

(

)

_geometry_forward_ribbon_color()

std::shared_ptr< GeometrySource > cil::_geometry_forward_ribbon_color

(

)

_geometry_forward_ribbon_scalar()

std::shared_ptr< GeometrySource > cil::_geometry_forward_ribbon_scalar

(

)

_geometry_line_dotdash()

std::shared_ptr< GeometrySource > cil::_geometry_line_dotdash

(

)

_geometry_line_dotdash_width()

std::shared_ptr< GeometrySource > cil::_geometry_line_dotdash_width

(

)

_geometry_line_width()

std::shared_ptr< GeometrySource > cil::_geometry_line_width

(

)

_geometry_meteor_cylinder_color()

std::shared_ptr< GeometrySource > cil::_geometry_meteor_cylinder_color

(

)

_geometry_meteor_cylinder_scalar()

std::shared_ptr< GeometrySource > cil::_geometry_meteor_cylinder_scalar

(

)

_geometry_pipe()

std::shared_ptr< Geometry > cil::_geometry_pipe	(	const float	radius = 1.0,
		const float	height = 1.0,
		const int	slices = 36 )

_geometry_quad()

std::shared_ptr< Geometry > cil::_geometry_quad	(	const Vector3f &	v0 = vec3(-1, -1, 0),
		const Vector3f &	v1 = vec3(1, -1, 0),
		const Vector3f &	v2 = vec3(1, 1, 0),
		const Vector3f &	v3 = vec3(-1, 1, 0) )

_geometry_ribbon_color()

std::shared_ptr< GeometrySource > cil::_geometry_ribbon_color

(

)

_geometry_ribbon_scalar()

std::shared_ptr< GeometrySource > cil::_geometry_ribbon_scalar

(

)

_geometry_scale_color()

std::shared_ptr< GeometrySource > cil::_geometry_scale_color

(

)

_geometry_scale_scalar()

std::shared_ptr< GeometrySource > cil::_geometry_scale_scalar

(

)

_geometry_sphere()

std::shared_ptr< Geometry > cil::_geometry_sphere	(	const float	radius = 1.0,
		const int	slices = 24,
		const int	stacks = 24 )

_geometry_torus()

std::shared_ptr< Geometry > cil::_geometry_torus	(	const float	radius = 1.0,
		const float	tubeRadius = 0.1,
		const int	sides = 20,
		const int	rings = 30 )

_geometry_triangle()

std::shared_ptr< Geometry > cil::_geometry_triangle	(	const Vector3f &	v0 = vec3(-1, -1, 0),
		const Vector3f &	v1 = vec3(1, -1, 0),
		const Vector3f &	v2 = vec3(0, 1, 0) )

_geometry_unit_cube()

std::shared_ptr< Geometry > cil::_geometry_unit_cube

(

)

_geometry_unit_cube_outline()

std::shared_ptr< Geometry > cil::_geometry_unit_cube_outline

(

)

_geometry_unit_sphere()

std::shared_ptr< Geometry > cil::_geometry_unit_sphere

(

)

_ghostwhite()

std::shared_ptr< Color3f > cil::_ghostwhite

(

)

_gold()

std::shared_ptr< Color3f > cil::_gold

(

)

_goldenrod()

std::shared_ptr< Color3f > cil::_goldenrod

(

)

_gray()

std::shared_ptr< Color3f > cil::_gray

(

)

_green()

std::shared_ptr< Color3f > cil::_green

(

)

_greenyellow()

std::shared_ptr< Color3f > cil::_greenyellow

(

)

_grey()

std::shared_ptr< Color3f > cil::_grey

(

)

_honeydew()

std::shared_ptr< Color3f > cil::_honeydew

(

)

_hotpink()

std::shared_ptr< Color3f > cil::_hotpink

(

)

_i16array() [1/2]

Int16ArrayPtr cil::_i16array

(

const std::initializer_list< short > &

array

)

_i16array() [2/2]

Int16ArrayPtr cil::_i16array	(	int	size = 0,
		short *	data = nullptr,
		bool	copy = true )

_i32array() [1/2]

Int32ArrayPtr cil::_i32array

(

const std::initializer_list< int > &

array

)

_i32array() [2/2]

Int32ArrayPtr cil::_i32array	(	int	size = 0,
		int *	data = nullptr,
		bool	copy = true )

_i8array() [1/2]

Int8ArrayPtr cil::_i8array

(

const std::initializer_list< char > &

array

)

_i8array() [2/2]

Int8ArrayPtr cil::_i8array	(	int	size = 0,
		char *	data = nullptr,
		bool	copy = true )

_image2d()

Image2DPtr cil::_image2d	(	int	width,
		int	height,
		unsigned char *	data = nullptr )

_image2d_black_white()

std::shared_ptr< Image2D > cil::_image2d_black_white

(

)

_image2d_cool_warm()

std::shared_ptr< Image2D > cil::_image2d_cool_warm

(

)

_image2d_gray_red()

std::shared_ptr< Image2D > cil::_image2d_gray_red

(

)

_image2d_green_brown()

std::shared_ptr< Image2D > cil::_image2d_green_brown

(

)

_image2d_inferno()

std::shared_ptr< Image2D > cil::_image2d_inferno

(

)

_image2d_jet()

std::shared_ptr< Image2D > cil::_image2d_jet

(

)

_image2d_kindlmann()

std::shared_ptr< Image2D > cil::_image2d_kindlmann

(

)

_image2d_metal_casting()

std::shared_ptr< Image2D > cil::_image2d_metal_casting

(

)

_image2d_plasma()

std::shared_ptr< Image2D > cil::_image2d_plasma

(

)

_image2d_radiation()

std::shared_ptr< Image2D > cil::_image2d_radiation

(

)

_image2d_rainbow()

std::shared_ptr< Image2D > cil::_image2d_rainbow

(

)

_image2d_reverted_rainbow()

std::shared_ptr< Image2D > cil::_image2d_reverted_rainbow

(

)

_image2d_scheme()

std::shared_ptr< Image2D > cil::_image2d_scheme	(	const ColorScheme &	scheme = ColorScheme::rainbow(),
		int	nLevels = 256 )

_image2d_terrain()

std::shared_ptr< Image2D > cil::_image2d_terrain

(

)

_image2d_thermal()

std::shared_ptr< Image2D > cil::_image2d_thermal

(

)

_image2d_viridis()

std::shared_ptr< Image2D > cil::_image2d_viridis

(

)

_image2d_white_brown()

std::shared_ptr< Image2D > cil::_image2d_white_brown

(

)

_imageConvolute()

std::shared_ptr< Pass > cil::_imageConvolute	(	const std::shared_ptr< Pass > &	input,
		const std::shared_ptr< Matrix3f > &	factor )

_imageCube()

ImageCubePtr cil::_imageCube

(

const std::vector< Image2D > &

images

)

_imageDecal()

std::shared_ptr< ImageDecal > cil::_imageDecal	(	const std::shared_ptr< Image2D > &	image,
		const Vector3f &	position )

_imageProcess()

std::shared_ptr< Pass > cil::_imageProcess	(	const std::shared_ptr< Pass > &	input,
		const std::string &	snippet,
		const std::string &	declaration = "" )

_imageProcessMaterial()

std::shared_ptr< Material > cil::_imageProcessMaterial	(	const std::shared_ptr< ImageBuffer > &	image,
		const std::string &	snippet,
		const std::string &	declaration = "" )

_indianred()

std::shared_ptr< Color3f > cil::_indianred

(

)

_indigo()

std::shared_ptr< Color3f > cil::_indigo

(

)

_integer() [1/3]

IntegerPtr cil::_integer

(

)

_integer() [2/3]

IntegerPtr cil::_integer

(

const Integer &

other

)

_integer() [3/3]

IntegerPtr cil::_integer

(

int

v

)

_intenseSharpen()

std::shared_ptr< Pass > cil::_intenseSharpen

(

const std::shared_ptr< Pass > &

input

)

_ivec2() [1/5]

Vector2iPtr cil::_ivec2

(

)

_ivec2() [2/5]

Vector2iPtr cil::_ivec2

(

const Vector2i &

other

)

_ivec2() [3/5]

Vector2iPtr cil::_ivec2

(

const Vector3i &

other

)

_ivec2() [4/5]

Vector2iPtr cil::_ivec2

(

const Vector4i &

other

)

_ivec2() [5/5]

Vector2iPtr cil::_ivec2	(	int	x,
		int	y )

_ivec3() [1/5]

Vector3iPtr cil::_ivec3

(

)

_ivec3() [2/5]

Vector3iPtr cil::_ivec3	(	const Vector2i &	other,
		int	z = 0 )

_ivec3() [3/5]

Vector3iPtr cil::_ivec3

(

const Vector3i &

other

)

_ivec3() [4/5]

Vector3iPtr cil::_ivec3

(

const Vector4i &

other

)

_ivec3() [5/5]

Vector3iPtr cil::_ivec3	(	int	x,
		int	y,
		int	z )

_ivec4() [1/5]

Vector4iPtr cil::_ivec4

(

)

_ivec4() [2/5]

Vector4iPtr cil::_ivec4	(	const Vector2i &	other,
		int	z = 0,
		int	w = 0 )

_ivec4() [3/5]

Vector4iPtr cil::_ivec4	(	const Vector3i &	other,
		int	w = 0 )

_ivec4() [4/5]

Vector4iPtr cil::_ivec4

(

const Vector4i &

other

)

_ivec4() [5/5]

Vector4iPtr cil::_ivec4	(	int	x,
		int	y,
		int	z,
		int	w )

_ivory()

std::shared_ptr< Color3f > cil::_ivory

(

)

_khaki()

std::shared_ptr< Color3f > cil::_khaki

(

)

_laplacian()

std::shared_ptr< Pass > cil::_laplacian

(

const std::shared_ptr< Pass > &

input

)

_lavender()

std::shared_ptr< Color3f > cil::_lavender

(

)

_lavenderblush()

std::shared_ptr< Color3f > cil::_lavenderblush

(

)

_lawngreen()

std::shared_ptr< Color3f > cil::_lawngreen

(

)

_legendPass()

std::shared_ptr< LegendPass > cil::_legendPass

(

const std::shared_ptr< Vector2i > &

backgroundSize

)

_lemonchiffon()

std::shared_ptr< Color3f > cil::_lemonchiffon

(

)

_lightblue()

std::shared_ptr< Color3f > cil::_lightblue

(

)

_lightcoral()

std::shared_ptr< Color3f > cil::_lightcoral

(

)

_lightcyan()

std::shared_ptr< Color3f > cil::_lightcyan

(

)

_lightgoldenrodyellow()

std::shared_ptr< Color3f > cil::_lightgoldenrodyellow

(

)

_lightgray()

std::shared_ptr< Color3f > cil::_lightgray

(

)

_lightgreen()

std::shared_ptr< Color3f > cil::_lightgreen

(

)

_lightgrey()

std::shared_ptr< Color3f > cil::_lightgrey

(

)

_lightpink()

std::shared_ptr< Color3f > cil::_lightpink

(

)

_lightsalmon()

std::shared_ptr< Color3f > cil::_lightsalmon

(

)

_lightseagreen()

std::shared_ptr< Color3f > cil::_lightseagreen

(

)

_lightskyblue()

std::shared_ptr< Color3f > cil::_lightskyblue

(

)

_lightslategray()

std::shared_ptr< Color3f > cil::_lightslategray

(

)

_lightslategrey()

std::shared_ptr< Color3f > cil::_lightslategrey

(

)

_lightsteelblue()

std::shared_ptr< Color3f > cil::_lightsteelblue

(

)

_lightyellow()

std::shared_ptr< Color3f > cil::_lightyellow

(

)

_lime()

std::shared_ptr< Color3f > cil::_lime

(

)

_limegreen()

std::shared_ptr< Color3f > cil::_limegreen

(

)

_line()

LinePtr cil::_line

(

float

width = 1.0f

)

_line_loop() [1/5]

ElementIndicesPtr cil::_line_loop	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_loop() [2/5]

ElementIndicesPtr cil::_line_loop	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_loop() [3/5]

ElementIndicesPtr cil::_line_loop	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_loop() [4/5]

ElementIndicesPtr cil::_line_loop	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_loop() [5/5]

ArrayIndicesPtr cil::_line_loop	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_line_strip() [1/5]

ElementIndicesPtr cil::_line_strip	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_strip() [2/5]

ElementIndicesPtr cil::_line_strip	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_strip() [3/5]

ElementIndicesPtr cil::_line_strip	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_strip() [4/5]

ElementIndicesPtr cil::_line_strip	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_line_strip() [5/5]

ArrayIndicesPtr cil::_line_strip	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_lineHandler()

std::shared_ptr< LineHandler > cil::_lineHandler

(

const std::shared_ptr< Matrix4f > &

matrix

)

_linen()

std::shared_ptr< Color3f > cil::_linen

(

)

_lines() [1/5]

ElementIndicesPtr cil::_lines	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_lines() [2/5]

ElementIndicesPtr cil::_lines	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_lines() [3/5]

ElementIndicesPtr cil::_lines	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_lines() [4/5]

ElementIndicesPtr cil::_lines	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_lines() [5/5]

ArrayIndicesPtr cil::_lines	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_locatorPass()

std::shared_ptr< LocatorPass > cil::_locatorPass	(	const std::shared_ptr< Background > &	background,
		const std::shared_ptr< Camera > &	camera )

_luminance()

std::shared_ptr< Pass > cil::_luminance

(

const std::shared_ptr< Pass > &

input

)

_magenta()

std::shared_ptr< Color3f > cil::_magenta

(

)

_manipulator()

std::shared_ptr< MouseManipulator > cil::_manipulator

(

)

_manipulator_navigation()

std::shared_ptr< NavigationManipulator > cil::_manipulator_navigation	(	std::shared_ptr< Camera > &	camera,
		const std::shared_ptr< Vector2i > &	windowSize,
		const std::shared_ptr< BoundingBox > &	boundingBox = nullptr )

_maroon()

std::shared_ptr< Color3f > cil::_maroon

(

)

_mat2() [1/6]

Matrix2fPtr cil::_mat2

(

)

_mat2() [2/6]

Matrix2fPtr cil::_mat2

(

const Matrix2f &

other

)

_mat2() [3/6]

Matrix2fPtr cil::_mat2

(

const Matrix3f &

other

)

_mat2() [4/6]

Matrix2fPtr cil::_mat2

(

const Matrix4f &

other

)

_mat2() [5/6]

Matrix2fPtr cil::_mat2	(	const Vector2f &	c0,
		const Vector2f &	c1 )

_mat2() [6/6]

Matrix2fPtr cil::_mat2	(	float	e00,
		float	e01,
		float	e10,
		float	e11 )

_mat3() [1/6]

Matrix3fPtr cil::_mat3

(

)

_mat3() [2/6]

Matrix3fPtr cil::_mat3

(

const Matrix2f &

other

)

_mat3() [3/6]

Matrix3fPtr cil::_mat3

(

const Matrix3f &

other

)

_mat3() [4/6]

Matrix3fPtr cil::_mat3

(

const Matrix4f &

other

)

_mat3() [5/6]

Matrix3fPtr cil::_mat3	(	const Vector3f &	c0,
		const Vector3f &	c1,
		const Vector3f &	c2 )

_mat3() [6/6]

Matrix3fPtr cil::_mat3	(	float	e00,
		float	e01,
		float	e02,
		float	e10,
		float	e11,
		float	e12,
		float	e20,
		float	e21,
		float	e22 )

_mat4() [1/6]

Matrix4fPtr cil::_mat4

(

)

_mat4() [2/6]

Matrix4fPtr cil::_mat4

(

const Matrix2f &

other

)

_mat4() [3/6]

Matrix4fPtr cil::_mat4

(

const Matrix3f &

other

)

_mat4() [4/6]

Matrix4fPtr cil::_mat4

(

const Matrix4f &

other

)

_mat4() [5/6]

Matrix4fPtr cil::_mat4	(	const Vector4f &	c0,
		const Vector4f &	c1,
		const Vector4f &	c2,
		const Vector4f &	c3 )

_mat4() [6/6]

Matrix4fPtr cil::_mat4	(	float	e00,
		float	e01,
		float	e02,
		float	e03,
		float	e10,
		float	e11,
		float	e12,
		float	e13,
		float	e20,
		float	e21,
		float	e22,
		float	e23,
		float	e30,
		float	e31,
		float	e32,
		float	e33 )

_material() [1/13]

MaterialPtr cil::_material	(	const ProgramPtr &	program,
		const std::map< std::string, VariantPtr > &	parameters )

_material() [2/13]

MaterialPtr cil::_material	(	const ProgramPtr &	program,
		const std::map< std::string, VariantPtr > &	parameters,
		const std::vector< StatePtr > &	states )

_material() [3/13]

MaterialPtr cil::_material	(	const ProgramPtr &	program,
		const std::shared_ptr< std::vector< StatePtr > > &	states )

_material() [4/13]

MaterialPtr cil::_material	(	const ProgramPtr &	program,
		const std::vector< StatePtr > &	states )

_material() [5/13]

MaterialPtr cil::_material	(	const ProgramPtr &	program = nullptr,
		const std::shared_ptr< std::map< std::string, VariantPtr > > &	parameters = nullptr,
		const std::shared_ptr< std::vector< StatePtr > > &	states = nullptr )

_material() [6/13]

MaterialPtr cil::_material

(

const std::map< std::string, VariantPtr > &

parameters

)

_material() [7/13]

MaterialPtr cil::_material	(	const std::map< std::string, VariantPtr > &	parameters,
		const std::vector< StatePtr > &	states )

_material() [8/13]

MaterialPtr cil::_material	(	const std::shared_ptr< std::map< std::string, VariantPtr > > &	parameters,
		const std::shared_ptr< std::vector< StatePtr > > &	states = nullptr )

_material() [9/13]

MaterialPtr cil::_material

(

const std::vector< SourcePtr > &

sources

)

_material() [10/13]

MaterialPtr cil::_material	(	const std::vector< SourcePtr > &	sources,
		const std::map< std::string, VariantPtr > &	parameters )

_material() [11/13]

MaterialPtr cil::_material	(	const std::vector< SourcePtr > &	sources,
		const std::map< std::string, VariantPtr > &	parameters,
		const std::vector< StatePtr > &	states )

_material() [12/13]

MaterialPtr cil::_material	(	const std::vector< SourcePtr > &	sources,
		const std::vector< StatePtr > &	states )

_material() [13/13]

MaterialPtr cil::_material

(

const std::vector< StatePtr > &

states

)

_material_block() [1/2]

std::shared_ptr< Material > cil::_material_block	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_block() [2/2]

std::shared_ptr< Material > cil::_material_block	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

_material_block_outline()

std::shared_ptr< Material > cil::_material_block_outline	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_cloud() [1/2]

std::shared_ptr< Material > cil::_material_cloud	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	radius )

_material_cloud() [2/2]

std::shared_ptr< Material > cil::_material_cloud	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	radius )

_material_cylinder() [1/2]

std::shared_ptr< Material > cil::_material_cylinder	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width )

_material_cylinder() [2/2]

std::shared_ptr< Material > cil::_material_cylinder	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width )

_material_fixed_sphere() [1/2]

std::shared_ptr< Material > cil::_material_fixed_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize )

_material_fixed_sphere() [2/2]

std::shared_ptr< Material > cil::_material_fixed_sphere	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

_material_fixed_vector() [1/2]

std::shared_ptr< Material > cil::_material_fixed_vector	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_fixed_vector() [2/2]

std::shared_ptr< Material > cil::_material_fixed_vector	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

_material_flat()

std::shared_ptr< Material > cil::_material_flat

(

const std::shared_ptr< Color3f > &

color

)

_material_forward_cylinder() [1/2]

std::shared_ptr< Material > cil::_material_forward_cylinder	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_cylinder() [2/2]

std::shared_ptr< Material > cil::_material_forward_cylinder	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_fixed_sphere() [1/2]

std::shared_ptr< Material > cil::_material_forward_fixed_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_fixed_sphere() [2/2]

std::shared_ptr< Material > cil::_material_forward_fixed_sphere	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_ribbon() [1/2]

std::shared_ptr< Material > cil::_material_forward_ribbon	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_ribbon() [2/2]

std::shared_ptr< Material > cil::_material_forward_ribbon	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_sphere() [1/2]

std::shared_ptr< Material > cil::_material_forward_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

_material_forward_sphere() [2/2]

std::shared_ptr< Material > cil::_material_forward_sphere	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

_material_gouraud() [1/3]

std::shared_ptr< Material > cil::_material_gouraud

(

const std::shared_ptr< Color3f > &

color

)

_material_gouraud() [2/3]

std::shared_ptr< Material > cil::_material_gouraud

(

const std::shared_ptr< Image2D > &

image

)

_material_gouraud() [3/3]

std::shared_ptr< Material > cil::_material_gouraud

(

const std::shared_ptr< ImageCube > &

image

)

_material_head_light() [1/4]

std::shared_ptr< Material > cil::_material_head_light

(

const std::shared_ptr< Color3f > &

color

)

_material_head_light() [2/4]

std::shared_ptr< Material > cil::_material_head_light

(

const std::shared_ptr< Image2D > &

image

)

_material_head_light() [3/4]

std::shared_ptr< Material > cil::_material_head_light	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

_material_head_light() [4/4]

std::shared_ptr< Material > cil::_material_head_light

(

const std::shared_ptr< ImageCube > &

image

)

_material_line()

std::shared_ptr< Material > cil::_material_line	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width = _real(1.0f),
		LineStyle	style = LineStyle::Solid )

_material_meteor_cylinder() [1/2]

std::shared_ptr< Material > cil::_material_meteor_cylinder	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	length,
		const std::shared_ptr< Real > &	currentTime )

_material_meteor_cylinder() [2/2]

std::shared_ptr< Material > cil::_material_meteor_cylinder	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	length,
		const std::shared_ptr< Real > &	currentTime )

_material_meteor_line() [1/2]

std::shared_ptr< Material > cil::_material_meteor_line	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	length,
		const std::shared_ptr< Real > &	currentTime )

_material_meteor_line() [2/2]

std::shared_ptr< Material > cil::_material_meteor_line	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	length,
		const std::shared_ptr< Real > &	currentTime )

_material_offset_cylinder() [1/2]

std::shared_ptr< Material > cil::_material_offset_cylinder	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

_material_offset_cylinder() [2/2]

std::shared_ptr< Material > cil::_material_offset_cylinder	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

_material_offset_fixed_sphere() [1/2]

std::shared_ptr< Material > cil::_material_offset_fixed_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

_material_offset_fixed_sphere() [2/2]

std::shared_ptr< Material > cil::_material_offset_fixed_sphere	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

_material_offset_outline() [1/2]

std::shared_ptr< Material > cil::_material_offset_outline	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_offset_outline() [2/2]

std::shared_ptr< Material > cil::_material_offset_outline	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

_material_offset_shaded() [1/2]

std::shared_ptr< Material > cil::_material_offset_shaded	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_offset_shaded() [2/2]

std::shared_ptr< Material > cil::_material_offset_shaded	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

_material_offset_sphere() [1/2]

std::shared_ptr< Material > cil::_material_offset_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

_material_offset_sphere() [2/2]

std::shared_ptr< Material > cil::_material_offset_sphere	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

_material_offset_strip() [1/2]

std::shared_ptr< Material > cil::_material_offset_strip	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_offset_strip() [2/2]

std::shared_ptr< Material > cil::_material_offset_strip	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Integer > &	strips,
		const std::shared_ptr< Real > &	factor )

_material_offset_transparent() [1/2]

std::shared_ptr< Material > cil::_material_offset_transparent	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	alpha,
		const std::shared_ptr< Real > &	factor )

_material_offset_transparent() [2/2]

std::shared_ptr< Material > cil::_material_offset_transparent	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	alpha,
		const std::shared_ptr< Real > &	factor )

_material_opaqueBackground()

std::shared_ptr< Material > cil::_material_opaqueBackground

(

)

_material_opaqueImage()

std::shared_ptr< Material > cil::_material_opaqueImage

(

)

_material_opaqueText()

std::shared_ptr< Material > cil::_material_opaqueText

(

)

_material_outline() [1/2]

std::shared_ptr< Material > cil::_material_outline

(

const std::shared_ptr< Color3f > &

color

)

_material_outline() [2/2]

std::shared_ptr< Material > cil::_material_outline	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

_material_pbr() [1/2]

std::shared_ptr< Material > cil::_material_pbr	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	metallic,
		const std::shared_ptr< Real > &	roughness )

_material_pbr() [2/2]

std::shared_ptr< Material > cil::_material_pbr	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	metallic,
		const std::shared_ptr< Real > &	roughness,
		const std::shared_ptr< ImageCube > &	image )

_material_phong() [1/3]

std::shared_ptr< Material > cil::_material_phong

(

const std::shared_ptr< Color3f > &

color

)

_material_phong() [2/3]

std::shared_ptr< Material > cil::_material_phong

(

const std::shared_ptr< Image2D > &

image

)

_material_phong() [3/3]

std::shared_ptr< Material > cil::_material_phong

(

const std::shared_ptr< ImageCube > &

image

)

_material_point_sprites_circle()

std::shared_ptr< Material > cil::_material_point_sprites_circle	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_disc()

std::shared_ptr< Material > cil::_material_point_sprites_disc	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_grid()

std::shared_ptr< Material > cil::_material_point_sprites_grid	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_icon()

std::shared_ptr< Material > cil::_material_point_sprites_icon	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_rose()

std::shared_ptr< Material > cil::_material_point_sprites_rose	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_sphere()

std::shared_ptr< Material > cil::_material_point_sprites_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_spiral()

std::shared_ptr< Material > cil::_material_point_sprites_spiral	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_square()

std::shared_ptr< Material > cil::_material_point_sprites_square	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_point_sprites_star()

std::shared_ptr< Material > cil::_material_point_sprites_star	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	pointSize = _real(24.0) )

_material_ribbon() [1/2]

std::shared_ptr< Material > cil::_material_ribbon	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width )

_material_ribbon() [2/2]

std::shared_ptr< Material > cil::_material_ribbon	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width )

_material_scale() [1/2]

std::shared_ptr< Material > cil::_material_scale

(

const std::shared_ptr< Color3f > &

color

)

_material_scale() [2/2]

std::shared_ptr< Material > cil::_material_scale	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

_material_shaded() [1/2]

std::shared_ptr< Material > cil::_material_shaded

(

const std::shared_ptr< Color3f > &

color

)

_material_shaded() [2/2]

std::shared_ptr< Material > cil::_material_shaded	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

_material_sphere() [1/2]

std::shared_ptr< Material > cil::_material_sphere	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

_material_sphere() [2/2]

std::shared_ptr< Material > cil::_material_sphere	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

_material_streamline() [1/2]

std::shared_ptr< Material > cil::_material_streamline	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	width )

_material_streamline() [2/2]

std::shared_ptr< Material > cil::_material_streamline	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width )

_material_strip() [1/2]

std::shared_ptr< Material > cil::_material_strip

(

const std::shared_ptr< Color3f > &

color

)

_material_strip() [2/2]

std::shared_ptr< Material > cil::_material_strip	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Integer > &	strips )

_material_toon()

std::shared_ptr< Material > cil::_material_toon	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Integer > &	level = _integer(6) )

_material_transparent() [1/2]

std::shared_ptr< Material > cil::_material_transparent	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	alpha )

_material_transparent() [2/2]

std::shared_ptr< Material > cil::_material_transparent	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	alpha )

_material_transparentBackground()

std::shared_ptr< Material > cil::_material_transparentBackground

(

)

_material_transparentImage()

std::shared_ptr< Material > cil::_material_transparentImage

(

)

_material_transparentText()

std::shared_ptr< Material > cil::_material_transparentText

(

)

_material_unlight() [1/4]

std::shared_ptr< Material > cil::_material_unlight

(

const std::shared_ptr< Color3f > &

color

)

_material_unlight() [2/4]

std::shared_ptr< Material > cil::_material_unlight

(

const std::shared_ptr< Image2D > &

image

)

_material_unlight() [3/4]

std::shared_ptr< Material > cil::_material_unlight	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

_material_unlight() [4/4]

std::shared_ptr< Material > cil::_material_unlight

(

const std::shared_ptr< ImageCube > &

image

)

_material_unlight_transparent()

std::shared_ptr< Material > cil::_material_unlight_transparent	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	alpha )

_material_vector() [1/2]

std::shared_ptr< Material > cil::_material_vector	(	const std::shared_ptr< Color3f > &	color,
		const std::shared_ptr< Real > &	factor )

_material_vector() [2/2]

std::shared_ptr< Material > cil::_material_vector	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

_mediumaquamarine()

std::shared_ptr< Color3f > cil::_mediumaquamarine

(

)

_mediumblue()

std::shared_ptr< Color3f > cil::_mediumblue

(

)

_mediumorchid()

std::shared_ptr< Color3f > cil::_mediumorchid

(

)

_mediumpurple()

std::shared_ptr< Color3f > cil::_mediumpurple

(

)

_mediumseagreen()

std::shared_ptr< Color3f > cil::_mediumseagreen

(

)

_mediumslateblue()

std::shared_ptr< Color3f > cil::_mediumslateblue

(

)

_mediumspringgreen()

std::shared_ptr< Color3f > cil::_mediumspringgreen

(

)

_mediumturquoise()

std::shared_ptr< Color3f > cil::_mediumturquoise

(

)

_mediumvioletred()

std::shared_ptr< Color3f > cil::_mediumvioletred

(

)

_mesh() [1/2]

MeshPtr cil::_mesh	(	const std::shared_ptr< std::vector< PrimitivePtr > > &	primitives = nullptr,
		const BoundingBoxPtr &	boundingBox = nullptr )

_mesh() [2/2]

MeshPtr cil::_mesh	(	const std::vector< PrimitivePtr > &	primitives,
		const BoundingBoxPtr &	boundingBox = nullptr )

_midnightblue()

std::shared_ptr< Color3f > cil::_midnightblue

(

)

_miniViewCube()

std::shared_ptr< MiniViewCube > cil::_miniViewCube	(	const std::shared_ptr< Renderer > &	renderer,
		const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< Vector2i > &	coordinate,
		const std::shared_ptr< Vector2i > &	backgroundSize,
		const std::shared_ptr< Vector2i > &	windowSize )

_minmax() [1/3]

MinMaxPtr cil::_minmax

(

)

_minmax() [2/3]

MinMaxPtr cil::_minmax

(

const MinMax &

other

)

_minmax() [3/3]

MinMaxPtr cil::_minmax	(	float	min,
		float	max )

_mintcream()

std::shared_ptr< Color3f > cil::_mintcream

(

)

_mistyrose()

std::shared_ptr< Color3f > cil::_mistyrose

(

)

_mixPass()

std::shared_ptr< Pass > cil::_mixPass

(

const std::shared_ptr< Pass > &

input

)

_moccasin()

std::shared_ptr< Color3f > cil::_moccasin

(

)

_navajowhite()

std::shared_ptr< Color3f > cil::_navajowhite

(

)

_navy()

std::shared_ptr< Color3f > cil::_navy

(

)

_node() [1/5]

NodePtr cil::_node	(	const MeshPtr &	mesh = nullptr,
		const std::shared_ptr< std::vector< NodePtr > > &	children = nullptr,
		const Matrix4fPtr &	transform = nullptr,
		const BoundingBoxPtr &	boundingBox = nullptr,
		const std::string &	name = "Node",
		const MaterialPtr &	material = nullptr,
		const GeometryPtr &	geometry = nullptr,
		const QueryPtr &	query = nullptr )

_node() [2/5]

NodePtr cil::_node	(	const std::shared_ptr< std::vector< NodePtr > > &	children,
		const Matrix4fPtr &	transform = nullptr,
		const BoundingBoxPtr &	boundingBox = nullptr,
		const std::string &	name = "Node",
		const MaterialPtr &	material = nullptr,
		const GeometryPtr &	geometry = nullptr,
		const QueryPtr &	query = nullptr )

_node() [3/5]

NodePtr cil::_node	(	const std::vector< NodePtr > &	nodes,
		const Matrix4fPtr &	transform = nullptr )

_node() [4/5]

NodePtr cil::_node	(	const std::vector< PrimitivePtr > &	primitives,
		const Matrix4fPtr &	transform = nullptr )

_node() [5/5]

NodePtr cil::_node	(	const std::vector< PrimitivePtr > &	primitives,
		const std::vector< NodePtr > &	nodes,
		const Matrix4fPtr &	transform = nullptr )

_nodes()

std::shared_ptr< std::vector< NodePtr > > cil::_nodes

(

const std::vector< NodePtr > &

nodes = {}

)

_normalSelector()

template<typename T >

std::shared_ptr< NormalSelector< T > > cil::_normalSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options,
		bool	buffered = false )

_oldlace()

std::shared_ptr< Color3f > cil::_oldlace

(

)

_olive()

std::shared_ptr< Color3f > cil::_olive

(

)

_olivedrab()

std::shared_ptr< Color3f > cil::_olivedrab

(

)

_orange()

std::shared_ptr< Color3f > cil::_orange

(

)

_orangered()

std::shared_ptr< Color3f > cil::_orangered

(

)

_orbitAction()

std::shared_ptr< OrbitAction > cil::_orbitAction	(	std::shared_ptr< MouseDraggedAction >	successor,
		std::shared_ptr< Camera >	camera,
		std::shared_ptr< Vector2i >	windowSize,
		std::shared_ptr< BoundingBox >	boundingBox = nullptr )

_orchid()

std::shared_ptr< Color3f > cil::_orchid

(

)

_orientationLocator()

std::shared_ptr< OrientationLocator > cil::_orientationLocator

(

)

_palegoldenrod()

std::shared_ptr< Color3f > cil::_palegoldenrod

(

)

_palegreen()

std::shared_ptr< Color3f > cil::_palegreen

(

)

_paleturquoise()

std::shared_ptr< Color3f > cil::_paleturquoise

(

)

_palevioletred()

std::shared_ptr< Color3f > cil::_palevioletred

(

)

_panAction()

std::shared_ptr< PanAction > cil::_panAction	(	std::shared_ptr< MouseDraggedAction >	successor,
		std::shared_ptr< Camera >	camera,
		std::shared_ptr< Vector2i >	windowSize )

_papayawhip()

std::shared_ptr< Color3f > cil::_papayawhip

(

)

_parameters()

std::shared_ptr< std::map< std::string, VariantPtr > > cil::_parameters

(

const std::map< std::string, VariantPtr > &

parameters = {}

)

_pass()

PassPtr cil::_pass	(	const NodePtr &	node = nullptr,
		const BackgroundPtr &	background = nullptr,
		const CameraPtr &	camera = nullptr,
		const TargetPtr &	target = nullptr,
		const std::string &	name = "Pass",
		bool	enabled = true )

_passThroughEdgeSelector()

template<typename T >

std::shared_ptr< PassThroughEdgeSelector< T > > cil::_passThroughEdgeSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options )

_passThroughFaceSelector()

template<typename T >

std::shared_ptr< PassThroughFaceSelector< T > > cil::_passThroughFaceSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options )

_passThroughVertexSelector()

template<typename T >

std::shared_ptr< PassThroughVertexSelector< T > > cil::_passThroughVertexSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options )

_peachpuff()

std::shared_ptr< Color3f > cil::_peachpuff

(

)

_peru()

std::shared_ptr< Color3f > cil::_peru

(

)

_pink()

std::shared_ptr< Color3f > cil::_pink

(

)

_plane() [1/4]

PlanePtr cil::_plane

(

)

_plane() [2/4]

PlanePtr cil::_plane

(

const Plane &

other

)

_plane() [3/4]

PlanePtr cil::_plane	(	const Vector3f &	origin,
		const Vector3f &	normal )

_plane() [4/4]

PlanePtr cil::_plane	(	float	x,
		float	y,
		float	z,
		float	w )

_planeClipping() [1/3]

std::shared_ptr< PlaneClipping > cil::_planeClipping

(

)

_planeClipping() [2/3]

std::shared_ptr< PlaneClipping > cil::_planeClipping	(	const std::shared_ptr< Vector3f > &	origin,
		const std::shared_ptr< Vector3f > &	normal )

_planeClipping() [3/3]

std::shared_ptr< PlaneClipping > cil::_planeClipping	(	float	a,
		float	b,
		float	c,
		float	d )

_planeLocator()

std::shared_ptr< PlaneLocator > cil::_planeLocator

(

)

_plum()

std::shared_ptr< Color3f > cil::_plum

(

)

_point()

PointPtr cil::_point	(	float	size = 1.0f,
		bool	programmable = false )

_point_point_sprites()

std::shared_ptr< Point > cil::_point_point_sprites

(

)

_point_sphere()

std::shared_ptr< Point > cil::_point_sphere

(

)

_points() [1/5]

ElementIndicesPtr cil::_points	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_points() [2/5]

ElementIndicesPtr cil::_points	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_points() [3/5]

ElementIndicesPtr cil::_points	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_points() [4/5]

ElementIndicesPtr cil::_points	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_points() [5/5]

ArrayIndicesPtr cil::_points	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_polygon()

PolygonPtr cil::_polygon

(

Polygon::Mode

mode = Polygon::Mode::FILL

)

_polygonOffset()

PolygonOffsetPtr cil::_polygonOffset	(	bool	enabled = false,
		float	factor = 0.0f,
		float	units = 0.0f )

_polygonOffset_opaque()

std::shared_ptr< PolygonOffset > cil::_polygonOffset_opaque

(

)

_polygonOffset_transparent()

std::shared_ptr< PolygonOffset > cil::_polygonOffset_transparent

(

)

_positionLocator()

std::shared_ptr< PositionLocator > cil::_positionLocator

(

)

_positionSelector()

template<typename T >

std::shared_ptr< PositionSelector< T > > cil::_positionSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options,
		bool	buffered = false )

_powderblue()

std::shared_ptr< Color3f > cil::_powderblue

(

)

_prewitt()

std::shared_ptr< Pass > cil::_prewitt

(

const std::shared_ptr< Pass > &

input

)

_primitive() [1/2]

PrimitivePtr cil::_primitive	(	const GeometryPtr &	geometry = nullptr,
		const MaterialPtr &	material = nullptr,
		int	priority = 0 )

_primitive() [2/2]

PrimitivePtr cil::_primitive	(	const MaterialPtr &	material,
		int	priority = 0 )

_primitives()

std::shared_ptr< std::vector< PrimitivePtr > > cil::_primitives

(

const std::vector< PrimitivePtr > &

primitives = {}

)

_primitiveSelector()

template<typename T >

std::shared_ptr< PrimitiveSelector< T > > cil::_primitiveSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options,
		bool	buffered = false )

_program() [1/6]

ProgramPtr cil::_program	(	const FragmentSourcePtr &	fragment,
		const GeometrySourcePtr &	geometry = nullptr )

_program() [2/6]

ProgramPtr cil::_program

(

const GeometrySourcePtr &

geometry

)

_program() [3/6]

ProgramPtr cil::_program

(

const std::string &

vertexString

)

_program() [4/6]

ProgramPtr cil::_program	(	const std::string &	vertexString,
		const std::string &	fragmentString )

_program() [5/6]

ProgramPtr cil::_program	(	const std::string &	vertexString,
		const std::string &	fragmentString,
		const std::string &	geometryString )

_program() [6/6]

ProgramPtr cil::_program	(	const VertexSourcePtr &	vertex = nullptr,
		const FragmentSourcePtr &	fragment = nullptr,
		const GeometrySourcePtr &	geometry = nullptr )

_purple()

std::shared_ptr< Color3f > cil::_purple

(

)

_quat() [1/4]

QuaternionPtr cil::_quat

(

)

_quat() [2/4]

QuaternionPtr cil::_quat

(

const Quaternion &

other

)

_quat() [3/4]

QuaternionPtr cil::_quat	(	const Vector3f &	axis,
		float	angle )

_quat() [4/4]

QuaternionPtr cil::_quat	(	float	x,
		float	y,
		float	z,
		float	w )

_radialTransformPath() [1/2]

std::shared_ptr< RadialTransformPath > cil::_radialTransformPath

(

)

_radialTransformPath() [2/2]

std::shared_ptr< RadialTransformPath > cil::_radialTransformPath	(	const std::shared_ptr< Vector3f > &	origin,
		const std::shared_ptr< Vector3f > &	normal )

_ray() [1/3]

RayPtr cil::_ray

(

)

_ray() [2/3]

RayPtr cil::_ray

(

const Ray &

other

)

_ray() [3/3]

RayPtr cil::_ray	(	const Vector3f &	origin,
		const Vector3f &	normal )

_real() [1/3]

RealPtr cil::_real

(

)

_real() [2/3]

RealPtr cil::_real

(

const Real &

other

)

_real() [3/3]

RealPtr cil::_real

(

float

v

)

_red()

std::shared_ptr< Color3f > cil::_red

(

)

_rollAction()

std::shared_ptr< RollAction > cil::_rollAction	(	std::shared_ptr< MouseDraggedAction >	successor,
		std::shared_ptr< Camera >	camera,
		std::shared_ptr< Vector2i >	windowSize )

_rosybrown()

std::shared_ptr< Color3f > cil::_rosybrown

(

)

_royalblue()

std::shared_ptr< Color3f > cil::_royalblue

(

)

_saddlebrown()

std::shared_ptr< Color3f > cil::_saddlebrown

(

)

_salmon()

std::shared_ptr< Color3f > cil::_salmon

(

)

_sampler()

SamplerPtr cil::_sampler	(	Sampler::Filter	minFilter = Sampler::Filter::LINEAR_MIPMAP_NEAREST,
		Sampler::Filter	magFilter = Sampler::Filter::LINEAR,
		Sampler::WrapMode	wrapS = Sampler::WrapMode::REPEAT,
		Sampler::WrapMode	wrapT = Sampler::WrapMode::REPEAT )

_sampler_decal()

std::shared_ptr< Sampler > cil::_sampler_decal

(

)

_samplerClamp()

SamplerPtr cil::_samplerClamp

(

)

_samplerCube()

SamplerPtr cil::_samplerCube

(

)

_samplerMirror()

SamplerPtr cil::_samplerMirror

(

)

_samplerRepeat()

SamplerPtr cil::_samplerRepeat

(

)

_sandybrown()

std::shared_ptr< Color3f > cil::_sandybrown

(

)

_scale()

std::shared_ptr< Scale > cil::_scale	(	const std::shared_ptr< Camera > &	camera,
		const std::shared_ptr< Background > &	background )

_scene() [1/2]

ScenePtr cil::_scene	(	const std::shared_ptr< std::vector< PassPtr > > &	passes = nullptr,
		const BoundingBoxPtr &	boundingBox = nullptr,
		const std::string &	name = "Scene" )

_scene() [2/2]

ScenePtr cil::_scene	(	const std::vector< PassPtr > &	passes,
		const BoundingBoxPtr &	boundingBox = nullptr,
		const std::string &	name = "Scene" )

_scissor()

ScissorPtr cil::_scissor	(	bool	enabled = false,
		int	x = 0,
		int	y = 0,
		int	width = 0,
		int	height = 0 )

_seagreen()

std::shared_ptr< Color3f > cil::_seagreen

(

)

_seashell()

std::shared_ptr< Color3f > cil::_seashell

(

)

_selectorEngine()

std::shared_ptr< SelectorEngine > cil::_selectorEngine	(	const std::shared_ptr< Renderer > &	renderer,
		const std::shared_ptr< Camera > &	camera,
		const std::shared_ptr< Vector2i > &	backgroundSize,
		const std::shared_ptr< Vector2i > &	windowSize )

_selectorOptions()

template<typename T >

std::shared_ptr< SelectorOptions< T > > cil::_selectorOptions	(	const std::shared_ptr< std::vector< std::shared_ptr< T > > > &	entities,
		const std::function< std::shared_ptr< Node >(std::shared_ptr< T >)> &	entity2node )

_shapeHandler()

std::shared_ptr< ShapeHandler > cil::_shapeHandler

(

const std::shared_ptr< Matrix4f > &

matrix

)

_sharpen()

std::shared_ptr< Pass > cil::_sharpen

(

const std::shared_ptr< Pass > &

input

)

_sienna()

std::shared_ptr< Color3f > cil::_sienna

(

)

_silhouette()

std::shared_ptr< Pass > cil::_silhouette

(

const std::shared_ptr< Pass > &

input

)

_silver()

std::shared_ptr< Color3f > cil::_silver

(

)

_simpleBackground()

BackgroundPtr cil::_simpleBackground	(	const Vector2iPtr &	size,
		const Color4fPtr &	colorMask = _clr4(0.7, 0.7, 0.7, 1.0),
		const RealPtr &	depthMask = _real(1.0),
		const IntegerPtr &	stencilMask = nullptr,
		const Vector2iPtr &	coordinate = _ivec2() )

_skyblue()

std::shared_ptr< Color3f > cil::_skyblue

(

)

_slateblue()

std::shared_ptr< Color3f > cil::_slateblue

(

)

_slategray()

std::shared_ptr< Color3f > cil::_slategray

(

)

_slategrey()

std::shared_ptr< Color3f > cil::_slategrey

(

)

_snow()

std::shared_ptr< Color3f > cil::_snow

(

)

_sobel()

std::shared_ptr< Pass > cil::_sobel

(

const std::shared_ptr< Pass > &

input

)

_spaceTransformPath() [1/2]

std::shared_ptr< SpaceTransformPath > cil::_spaceTransformPath

(

)

_spaceTransformPath() [2/2]

std::shared_ptr< SpaceTransformPath > cil::_spaceTransformPath

(

const std::shared_ptr< Vector3f > &

origin

)

_sphereClipping() [1/3]

std::shared_ptr< SphereClipping > cil::_sphereClipping

(

)

_sphereClipping() [2/3]

std::shared_ptr< SphereClipping > cil::_sphereClipping	(	const std::shared_ptr< Vector3f > &	position,
		float	radius )

_sphereClipping() [3/3]

std::shared_ptr< SphereClipping > cil::_sphereClipping	(	float	a,
		float	b,
		float	c,
		float	d )

_sphereLocator()

std::shared_ptr< SphereLocator > cil::_sphereLocator

(

)

_spline()

std::shared_ptr< Geometry > cil::_spline	(	const std::vector< Vector3f >	control_points,
		int	degree,
		BSplineCurve::Boundary	boundary,
		const int	slices )

_spline_fit()

std::shared_ptr< Geometry > cil::_spline_fit	(	const std::vector< Vector3f >	fit_points,
		BSplineCurve::Boundary	boundary,
		const int	slices )

_springgreen()

std::shared_ptr< Color3f > cil::_springgreen

(

)

_states()

std::shared_ptr< std::vector< StatePtr > > cil::_states

(

const std::vector< StatePtr > &

states = {}

)

_steelblue()

std::shared_ptr< Color3f > cil::_steelblue

(

)

_stencil()

StencilPtr cil::_stencil	(	bool	enabled = false,
		Stencil::Operation	sfail = Stencil::Operation::KEEP,
		Stencil::Operation	dpfail = Stencil::Operation::KEEP,
		Stencil::Operation	dppass = Stencil::Operation::KEEP,
		Stencil::Function	func = Stencil::Function::ALWAYS,
		int	ref = 0,
		int	mask = 0xFF )

_tan()

std::shared_ptr< Color3f > cil::_tan

(

)

_target() [1/2]

TargetPtr cil::_target

(

)

_target() [2/2]

TargetPtr cil::_target

(

const std::vector< ImageBufferPtr > &

array

)

_teal()

std::shared_ptr< Color3f > cil::_teal

(

)

_textDecal() [1/2]

std::shared_ptr< TextDecal > cil::_textDecal	(	const std::string &	text,
		const Vector3f &	position )

_textDecal() [2/2]

std::shared_ptr< TextDecal > cil::_textDecal	(	const std::wstring &	text,
		const Vector3f &	position )

_texture()

TexturePtr cil::_texture	(	int	unit,
		const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture0()

TexturePtr cil::_texture0	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture1()

TexturePtr cil::_texture1	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture2()

TexturePtr cil::_texture2	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture3()

TexturePtr cil::_texture3	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture4()

TexturePtr cil::_texture4	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture5()

TexturePtr cil::_texture5	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture6()

TexturePtr cil::_texture6	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_texture7()

TexturePtr cil::_texture7	(	const ImagePtr &	image,
		const SamplerPtr &	sampler = nullptr )

_thistle()

std::shared_ptr< Color3f > cil::_thistle

(

)

_timer()

std::shared_ptr< Timer > cil::_timer

(

)

_tomato()

std::shared_ptr< Color3f > cil::_tomato

(

)

_triangle_fan() [1/5]

ElementIndicesPtr cil::_triangle_fan	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_fan() [2/5]

ElementIndicesPtr cil::_triangle_fan	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_fan() [3/5]

ElementIndicesPtr cil::_triangle_fan	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_fan() [4/5]

ElementIndicesPtr cil::_triangle_fan	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_fan() [5/5]

ArrayIndicesPtr cil::_triangle_fan	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_triangle_strip() [1/5]

ElementIndicesPtr cil::_triangle_strip	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_strip() [2/5]

ElementIndicesPtr cil::_triangle_strip	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_strip() [3/5]

ElementIndicesPtr cil::_triangle_strip	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_strip() [4/5]

ElementIndicesPtr cil::_triangle_strip	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangle_strip() [5/5]

ArrayIndicesPtr cil::_triangle_strip	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_triangleBlur()

std::shared_ptr< Pass > cil::_triangleBlur

(

const std::shared_ptr< Pass > &

input

)

_triangles() [1/5]

ElementIndicesPtr cil::_triangles	(	const std::initializer_list< unsigned int > &	array,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangles() [2/5]

ElementIndicesPtr cil::_triangles	(	const Uint16ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangles() [3/5]

ElementIndicesPtr cil::_triangles	(	const Uint32ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangles() [4/5]

ElementIndicesPtr cil::_triangles	(	const Uint8ArrayPtr &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

_triangles() [5/5]

ArrayIndicesPtr cil::_triangles	(	int	count,
		int	first = 0,
		int	primCount = 0 )

_turquoise()

std::shared_ptr< Color3f > cil::_turquoise

(

)

_u16array() [1/2]

Uint16ArrayPtr cil::_u16array

(

const std::initializer_list< unsigned short > &

array

)

_u16array() [2/2]

Uint16ArrayPtr cil::_u16array	(	int	size = 0,
		unsigned short *	data = nullptr,
		bool	copy = true )

_u32array() [1/2]

Uint32ArrayPtr cil::_u32array

(

const std::initializer_list< unsigned int > &

array

)

_u32array() [2/2]

Uint32ArrayPtr cil::_u32array	(	int	size = 0,
		unsigned int *	data = nullptr,
		bool	copy = true )

_u8array() [1/2]

Uint8ArrayPtr cil::_u8array

(

const std::initializer_list< unsigned char > &

array

)

_u8array() [2/2]

Uint8ArrayPtr cil::_u8array	(	int	size = 0,
		unsigned char *	data = nullptr,
		bool	copy = true )

_vec2() [1/5]

Vector2fPtr cil::_vec2

(

)

_vec2() [2/5]

Vector2fPtr cil::_vec2

(

const Vector2f &

other

)

_vec2() [3/5]

Vector2fPtr cil::_vec2

(

const Vector3f &

other

)

_vec2() [4/5]

Vector2fPtr cil::_vec2

(

const Vector4f &

other

)

_vec2() [5/5]

Vector2fPtr cil::_vec2	(	float	x,
		float	y )

_vec3() [1/5]

Vector3fPtr cil::_vec3

(

)

_vec3() [2/5]

Vector3fPtr cil::_vec3	(	const Vector2f &	other,
		float	z = 0 )

_vec3() [3/5]

Vector3fPtr cil::_vec3

(

const Vector3f &

other

)

_vec3() [4/5]

Vector3fPtr cil::_vec3

(

const Vector4f &

other

)

_vec3() [5/5]

Vector3fPtr cil::_vec3	(	float	x,
		float	y,
		float	z )

_vec4() [1/5]

Vector4fPtr cil::_vec4

(

)

_vec4() [2/5]

Vector4fPtr cil::_vec4	(	const Vector2f &	other,
		float	z = 0,
		float	w = 0 )

_vec4() [3/5]

Vector4fPtr cil::_vec4	(	const Vector3f &	other,
		float	w = 0 )

_vec4() [4/5]

Vector4fPtr cil::_vec4

(

const Vector4f &

other

)

_vec4() [5/5]

Vector4fPtr cil::_vec4	(	float	x,
		float	y,
		float	z,
		float	w )

_vert()

VertexSourcePtr cil::_vert

(

const std::string &

text

)

_vertex_block_color()

std::shared_ptr< VertexSource > cil::_vertex_block_color

(

)

_vertex_block_outline()

std::shared_ptr< VertexSource > cil::_vertex_block_outline

(

)

_vertex_block_scalar()

std::shared_ptr< VertexSource > cil::_vertex_block_scalar

(

)

_vertex_cloud_color()

std::shared_ptr< VertexSource > cil::_vertex_cloud_color

(

)

_vertex_cloud_scalar()

std::shared_ptr< VertexSource > cil::_vertex_cloud_scalar

(

)

_vertex_fixed_sphere_color()

std::shared_ptr< VertexSource > cil::_vertex_fixed_sphere_color

(

)

_vertex_fixed_sphere_scalar()

std::shared_ptr< VertexSource > cil::_vertex_fixed_sphere_scalar

(

)

_vertex_fixed_vector_color()

std::shared_ptr< VertexSource > cil::_vertex_fixed_vector_color

(

)

_vertex_fixed_vector_scalar()

std::shared_ptr< VertexSource > cil::_vertex_fixed_vector_scalar

(

)

_vertex_flat_color()

std::shared_ptr< VertexSource > cil::_vertex_flat_color

(

)

_vertex_forward_fixed_sphere_color()

std::shared_ptr< VertexSource > cil::_vertex_forward_fixed_sphere_color

(

)

_vertex_forward_fixed_sphere_scalar()

std::shared_ptr< VertexSource > cil::_vertex_forward_fixed_sphere_scalar

(

)

_vertex_forward_ribbon_color()

std::shared_ptr< VertexSource > cil::_vertex_forward_ribbon_color

(

)

_vertex_forward_ribbon_scalar()

std::shared_ptr< VertexSource > cil::_vertex_forward_ribbon_scalar

(

)

_vertex_forward_sphere_color()

std::shared_ptr< VertexSource > cil::_vertex_forward_sphere_color

(

)

_vertex_forward_sphere_scalar()

std::shared_ptr< VertexSource > cil::_vertex_forward_sphere_scalar

(

)

_vertex_gouraud_color()

std::shared_ptr< VertexSource > cil::_vertex_gouraud_color

(

)

_vertex_gouraud_cube_texture()

std::shared_ptr< VertexSource > cil::_vertex_gouraud_cube_texture

(

)

_vertex_gouraud_texture()

std::shared_ptr< VertexSource > cil::_vertex_gouraud_texture

(

)

_vertex_head_light_color()

std::shared_ptr< VertexSource > cil::_vertex_head_light_color

(

)

_vertex_head_light_cube_texture()

std::shared_ptr< VertexSource > cil::_vertex_head_light_cube_texture

(

)

_vertex_head_light_scalar()

std::shared_ptr< VertexSource > cil::_vertex_head_light_scalar

(

)

_vertex_head_light_texture()

std::shared_ptr< VertexSource > cil::_vertex_head_light_texture

(

)

_vertex_line()

std::shared_ptr< VertexSource > cil::_vertex_line

(

)

_vertex_meteor_cylinder_color()

std::shared_ptr< VertexSource > cil::_vertex_meteor_cylinder_color

(

)

_vertex_meteor_cylinder_scalar()

std::shared_ptr< VertexSource > cil::_vertex_meteor_cylinder_scalar

(

)

_vertex_meteor_line_color()

std::shared_ptr< VertexSource > cil::_vertex_meteor_line_color

(

)

_vertex_meteor_line_scalar()

std::shared_ptr< VertexSource > cil::_vertex_meteor_line_scalar

(

)

_vertex_offset_cylinder_color()

std::shared_ptr< VertexSource > cil::_vertex_offset_cylinder_color

(

)

_vertex_offset_cylinder_scalar()

std::shared_ptr< VertexSource > cil::_vertex_offset_cylinder_scalar

(

)

_vertex_offset_fixed_sphere_color()

std::shared_ptr< VertexSource > cil::_vertex_offset_fixed_sphere_color

(

)

_vertex_offset_fixed_sphere_scalar()

std::shared_ptr< VertexSource > cil::_vertex_offset_fixed_sphere_scalar

(

)

_vertex_offset_outline_color()

std::shared_ptr< VertexSource > cil::_vertex_offset_outline_color

(

)

_vertex_offset_outline_scalar()

std::shared_ptr< VertexSource > cil::_vertex_offset_outline_scalar

(

)

_vertex_offset_shaded_color()

std::shared_ptr< VertexSource > cil::_vertex_offset_shaded_color

(

)

_vertex_offset_shaded_scalar()

std::shared_ptr< VertexSource > cil::_vertex_offset_shaded_scalar

(

)

_vertex_offset_sphere_color()

std::shared_ptr< VertexSource > cil::_vertex_offset_sphere_color

(

)

_vertex_offset_sphere_scalar()

std::shared_ptr< VertexSource > cil::_vertex_offset_sphere_scalar

(

)

_vertex_phong_color()

std::shared_ptr< VertexSource > cil::_vertex_phong_color

(

)

_vertex_phong_cube_texture()

std::shared_ptr< VertexSource > cil::_vertex_phong_cube_texture

(

)

_vertex_phong_scalar()

std::shared_ptr< VertexSource > cil::_vertex_phong_scalar

(

)

_vertex_phong_texture()

std::shared_ptr< VertexSource > cil::_vertex_phong_texture

(

)

_vertex_point_sprites()

std::shared_ptr< VertexSource > cil::_vertex_point_sprites

(

)

_vertex_ribbon_color()

std::shared_ptr< VertexSource > cil::_vertex_ribbon_color

(

)

_vertex_ribbon_scalar()

std::shared_ptr< VertexSource > cil::_vertex_ribbon_scalar

(

)

_vertex_scale_color()

std::shared_ptr< VertexSource > cil::_vertex_scale_color

(

)

_vertex_scale_scalar()

std::shared_ptr< VertexSource > cil::_vertex_scale_scalar

(

)

_vertex_sphere_color()

std::shared_ptr< VertexSource > cil::_vertex_sphere_color

(

)

_vertex_sphere_scalar()

std::shared_ptr< VertexSource > cil::_vertex_sphere_scalar

(

)

_vertex_transparent_color()

std::shared_ptr< VertexSource > cil::_vertex_transparent_color

(

)

_vertex_transparent_scalar()

std::shared_ptr< VertexSource > cil::_vertex_transparent_scalar

(

)

_vertex_unlight_color()

std::shared_ptr< VertexSource > cil::_vertex_unlight_color

(

)

_vertex_unlight_cube_texture()

std::shared_ptr< VertexSource > cil::_vertex_unlight_cube_texture

(

)

_vertex_unlight_scalar()

std::shared_ptr< VertexSource > cil::_vertex_unlight_scalar

(

)

_vertex_unlight_texture()

std::shared_ptr< VertexSource > cil::_vertex_unlight_texture

(

)

_vertex_vector_color()

std::shared_ptr< VertexSource > cil::_vertex_vector_color

(

)

_vertex_vector_scalar()

std::shared_ptr< VertexSource > cil::_vertex_vector_scalar

(

)

_vertexSelector()

template<typename T >

std::shared_ptr< VertexSelector< T > > cil::_vertexSelector	(	const std::shared_ptr< SelectorEngine > &	engine,
		const std::shared_ptr< SelectorOptions< T > > &	options,
		bool	buffered = true )

_vertices() [1/3]

VerticesPtr cil::_vertices	(	const Float32ArrayPtr &	buffer,
		int	offset = 0,
		unsigned int	stride = 0,
		unsigned int	divisor = 0 )

_vertices() [2/3]

VerticesPtr cil::_vertices	(	const Int32ArrayPtr &	buffer,
		int	offset = 0,
		unsigned int	stride = 0,
		unsigned int	divisor = 0 )

_vertices() [3/3]

VerticesPtr cil::_vertices	(	const std::initializer_list< float > &	array,
		int	offset = 0,
		unsigned int	stride = 0,
		unsigned int	divisor = 0 )

_verticesSet()

std::shared_ptr< std::map< std::string, VerticesPtr > > cil::_verticesSet

(

const std::map< std::string, VerticesPtr > &

verticesMap = {}

)

_violet()

std::shared_ptr< Color3f > cil::_violet

(

)

_wheat()

std::shared_ptr< Color3f > cil::_wheat

(

)

_white()

std::shared_ptr< Color3f > cil::_white

(

)

_whitesmoke()

std::shared_ptr< Color3f > cil::_whitesmoke

(

)

_yellow()

std::shared_ptr< Color3f > cil::_yellow

(

)

_yellowgreen()

std::shared_ptr< Color3f > cil::_yellowgreen

(

)

_zoomAction()

std::shared_ptr< ZoomAction > cil::_zoomAction	(	std::shared_ptr< MouseWheeledAction >	successor,
		std::shared_ptr< Camera >	camera,
		std::shared_ptr< Vector2i >	windowSize )

align() [1/2]

void cil::align	(	const std::shared_ptr< Camera > &	camera,
		const std::shared_ptr< BoundingBox > &	boundingBox,
		const Vector3f &	dir )

align() [2/2]

void cil::align	(	const std::shared_ptr< Camera > &	camera,
		const std::shared_ptr< BoundingBox > &	boundingBox,
		const Vector3f &	dir,
		const const Vector3f &	point )

center()

void cil::center	(	const std::shared_ptr< Camera > &	camera,
		const Vector3f &	point )

createBodyNode()

std::shared_ptr< Node > cil::createBodyNode	(	const VizBodyPtr &	vizBody,
		const Attributes &	attributes,
		const std::shared_ptr< ScenarioSettings > &	settings )

crop() [1/3]

std::shared_ptr< Camera > cil::crop	(	const std::shared_ptr< Camera > &	camera,
		const Vector2i &	backgroundSize,
		const Box2i &	box )

crop() [2/3]

std::shared_ptr< Camera > cil::crop	(	const std::shared_ptr< Camera > &	camera,
		const Vector2i &	backgroundSize,
		const Vector2i &	point )

crop() [3/3]

std::shared_ptr< Camera > cil::crop	(	const std::shared_ptr< Camera > &	camera,
		const Vector2i &	backgroundSize,
		const Vector2i &	topLeft,
		const Vector2i &	size )

extractDataModel()

VizPartPtrMap cil::extractDataModel	(	const DataModelPtr &	dataModel,
		const Parameters &	parameters )

extractDataPart()

VizPartPtr cil::extractDataPart	(	const DataPartPtr &	dataPart,
		const Parameters &	parameters )

findRay()

Ray cil::findRay	(	const std::shared_ptr< Camera > &	camera,
		const Vector2i &	point,
		const Vector2i &	windowSize )

fit()

void cil::fit	(	const std::shared_ptr< Camera > &	camera,
		const BoundingBox &	boundingBox,
		const Vector2i &	backgroundSize )

fromHex()

Color3f cil::fromHex

(

const std::string &

hex

)

fromHsl()

Color3f cil::fromHsl

(

const Hsl &

hsl

)

fromHsv()

Color3f cil::fromHsv

(

const Hsv &

hsv

)

fromRgb()

Color3f cil::fromRgb

(

const Rgb &

rgb

)

fromYuv()

Color3f cil::fromYuv

(

const Yuv &

yuv

)

getAspect()

float cil::getAspect

(

const Matrix4f &

matrix

)

Gets the aspect ratio of an orthographic projection matrix.

It checks if the height of the projection view is positive. If the height is positive, it calculates the aspect ratio by dividing the width by the height.

Parameters

matrix

A constant reference to a projection matrix.

Returns

Returns the ratio between the width and height of the view, but returns 0 if the height is 0.

getBoundingBox() [1/6]

BoundingBoxPtr cil::getBoundingBox	(	const GeometryPtr &	geometry,
		const std::string &	attribName = "positions" )

getBoundingBox() [2/6]

BoundingBoxPtr cil::getBoundingBox

(

const MeshPtr &

mesh

)

getBoundingBox() [3/6]

BoundingBoxPtr cil::getBoundingBox

(

const NodePtr &

node

)

getBoundingBox() [4/6]

BoundingBoxPtr cil::getBoundingBox

(

const PassPtr &

pass

)

getBoundingBox() [5/6]

BoundingBoxPtr cil::getBoundingBox

(

const PrimitivePtr &

primitive

)

getBoundingBox() [6/6]

BoundingBoxPtr cil::getBoundingBox

(

const ScenePtr &

scene

)

getOrthoMinMax()

MinMax cil::getOrthoMinMax

(

const Matrix4f &

matrix

)

Calculates the near and far clipping planes of the orthographic projection.

Parameters

matrix

A constant reference to a projection matrix.

Returns

A MinMax object containing the calculated near and far clipping planes.

getOrthoSize()

Vector2f cil::getOrthoSize

(

const Matrix4f &

matrix

)

Calculates the width and height of the orthographic projection matrix, and returns a Vector2f object containing the calculated width and height.

An orthographic projection matrix can transform 3D points into 2D clip space coordinates, assuming a constant depth value across the entire view.

Parameters

matrix

A constant reference to a projection matrix.

getViewSpec()

ViewSpec cil::getViewSpec

(

const Matrix4f &

matrix

)

Gets the ViewSpec vectors from a specified matrix.

The matrix represents the view transformation in a 3D scene and each column of the matrix represents a vector.

Parameters

matrix

A constant reference to a 4X4 matrix.

Returns

A ViewSpec object.

home() [1/2]

void cil::home	(	const std::shared_ptr< Camera > &	camera,
		const BoundingBox &	boundingBox )

home() [2/2]

void cil::home	(	const std::shared_ptr< Camera > &	camera,
		const BoundingBox &	boundingBox,
		const Vector2i &	backgroundSize )

look()

void cil::look	(	const std::shared_ptr< Camera > &	camera,
		const BoundingBox &	boundingBox,
		const std::string &	dir )

lookAt()

void cil::lookAt	(	Matrix4f &	viewMatrix,
		const Vector3f &	eye,
		const Vector3f &	vrp,
		const Vector3f &	up )

makeAttributesOverwriter()

AttributesOverwriterPtr cil::makeAttributesOverwriter

(

AttributesOverwriter

callback

)

openSolution()

DataSolutionPtr cil::openSolution	(	const std::string &	fileName,
		const std::string &	typeName = "AUTO" )

operator&()

Attributes::Display cil::operator&	(	Attributes::Display	display1,
		Attributes::Display	display2 )

operator|()

Attributes::Display cil::operator|	(	Attributes::Display	display1,
		Attributes::Display	display2 )

orbit() [1/2]

void cil::orbit	(	const std::shared_ptr< Camera > &	camera,
		const Quaternion &	rot )

orbit() [2/2]

void cil::orbit	(	const std::shared_ptr< Camera > &	camera,
		const Quaternion &	rot,
		const Vector3f &	center )

pan()

void cil::pan	(	const std::shared_ptr< Camera > &	camera,
		const Vector2f &	offset )

project()

void cil::project	(	const std::shared_ptr< Camera > &	camera,
		const BoundingBox &	boundingBox,
		const Vector2i &	backgroundSize )

readBYUFile()

DataSolutionPtr cil::readBYUFile

(

const std::string &

strFileName

)

readCGNSFile()

DataSolutionPtr cil::readCGNSFile

(

const std::string &

strFileName

)

readDICOMFile()

DataSolutionPtr cil::readDICOMFile

(

const std::string &

strFileName

)

readEnSightFile()

DataSolutionPtr cil::readEnSightFile

(

const std::string &

strFileName

)

readGambitFile()

DataSolutionPtr cil::readGambitFile

(

const std::string &

strFileName

)

readLSDynaFile()

DataSolutionPtr cil::readLSDynaFile

(

const std::string &

strFileName

)

readOBJFile()

DataSolutionPtr cil::readOBJFile

(

const std::string &

strFileName

)

readOpenFoamFile()

DataSolutionPtr cil::readOpenFoamFile

(

const std::string &

strFileName

)

readPLYFile()

DataSolutionPtr cil::readPLYFile

(

const std::string &

strFileName

)

readPVDFile()

DataSolutionPtr cil::readPVDFile

(

const std::string &

fileName

)

readSLCFile()

DataSolutionPtr cil::readSLCFile

(

const std::string &

strFileName

)

readSTLFile()

DataSolutionPtr cil::readSTLFile

(

const std::string &

strFileName

)

readTecplotFile()

DataSolutionPtr cil::readTecplotFile

(

const std::string &

strFileName

)

readVTIFile()

DataSolutionPtr cil::readVTIFile

(

const std::string &

strFileName

)

readVTKFile()

DataSolutionPtr cil::readVTKFile

(

const std::string &

strFileName

)

readVTMFile()

DataSolutionPtr cil::readVTMFile

(

const std::string &

strFileName

)

readVTPFile()

DataSolutionPtr cil::readVTPFile

(

const std::string &

strFileName

)

readVTRFile()

DataSolutionPtr cil::readVTRFile

(

const std::string &

strFileName

)

readVTSFile()

DataSolutionPtr cil::readVTSFile

(

const std::string &

strFileName

)

readVTUFile()

DataSolutionPtr cil::readVTUFile

(

const std::string &

strFileName

)

resize()

void cil::resize	(	const std::shared_ptr< Camera > &	camera,
		const Vector2i &	windowSize )

roll()

void cil::roll	(	const std::shared_ptr< Camera > &	camera,
		const float	angle )

setAspect()

void cil::setAspect	(	Matrix4f &	matrix,
		float	aspect )

Scales the width of a orthographic view based on the desired aspect ratio while keeping the height constant.

Parameters

matrix	A reference to a project matrix and it will be modified by the funcion.
aspect	The desired aspect ratio.

setOrthoMinMax()

void cil::setOrthoMinMax	(	Matrix4f &	matrix,
		const MinMax &	mm )

Modifying a projection matrix with a desired near and far clipping planes for the orthographic projection.

Parameters

matrix	A reference to a project matrix and it will be modified by the funcion.
mm	A constant reference to a MinMax object, representing the desired near and far clippling planes for the orthographic view.

setOrthoSize()

void cil::setOrthoSize	(	Matrix4f &	matrix,
		const Vector2f &	size )

Modifying a projection matrix with a desired size of orthographic view.

Parameters

matrix	A reference to a project matrix and it will be modified by the funcion.
size	A constant reference to a Vector2f object, representing the desired width and height for the orthographic view.

setViewSpec()

void cil::setViewSpec	(	Matrix4f &	matrix,
		const ViewSpec &	viewSpec )

Sets the ViewSpec to the matrix, It can change the matrix elements.

It extracts the right, up, direction and eye position vectors of the viewSpec, and replaces the contents of the original matrix.

Parameters

matrix	A reference to a 4X4 matrix, this will be modified by this function.
viewSpec	A constant reference to a ViewSpec object.

toHex() [1/2]

std::string cil::toHex

(

const Color3f &

color

)

toHex() [2/2]

std::string cil::toHex

(

const Color4f &

color

)

toHsl() [1/2]

Hsl cil::toHsl

(

const Color3f &

color

)

toHsl() [2/2]

Hsl cil::toHsl

(

const Color4f &

color

)

toHsv() [1/2]

Hsv cil::toHsv

(

const Color3f &

color

)

toHsv() [2/2]

Hsv cil::toHsv

(

const Color4f &

color

)

toRgb() [1/2]

Rgb cil::toRgb

(

const Color3f &

color

)

toRgb() [2/2]

Rgb cil::toRgb

(

const Color4f &

color

)

toYuv() [1/2]

Yuv cil::toYuv

(

const Color3f &

color

)

toYuv() [2/2]

Yuv cil::toYuv

(

const Color4f &

color

)

vizAnimCylinderColorFragment()

std::shared_ptr< FragmentSource > cil::vizAnimCylinderColorFragment

(

)

vizAnimCylinderColorGeometry()

std::shared_ptr< GeometrySource > cil::vizAnimCylinderColorGeometry

(

)

vizAnimCylinderMaterial() [1/2]

std::shared_ptr< Material > cil::vizAnimCylinderMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

vizAnimCylinderMaterial() [2/2]

std::shared_ptr< Material > cil::vizAnimCylinderMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

vizAnimCylinderScalarFragment()

std::shared_ptr< FragmentSource > cil::vizAnimCylinderScalarFragment

(

)

vizAnimCylinderScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizAnimCylinderScalarGeometry

(

)

vizAnimLineColorFragment()

std::shared_ptr< FragmentSource > cil::vizAnimLineColorFragment

(

)

vizAnimLineColorVertex()

std::shared_ptr< VertexSource > cil::vizAnimLineColorVertex

(

)

vizAnimLineMaterial() [1/2]

std::shared_ptr< Material > cil::vizAnimLineMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	currentTime )

vizAnimLineMaterial() [2/2]

std::shared_ptr< Material > cil::vizAnimLineMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	currentTime )

vizAnimLineScalarFragment()

std::shared_ptr< FragmentSource > cil::vizAnimLineScalarFragment

(

)

vizAnimLineScalarVertex()

std::shared_ptr< VertexSource > cil::vizAnimLineScalarVertex

(

)

vizAnimMeteorColorFragment()

std::shared_ptr< FragmentSource > cil::vizAnimMeteorColorFragment

(

)

vizAnimMeteorMaterial() [1/2]

std::shared_ptr< Material > cil::vizAnimMeteorMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	length,
		const std::shared_ptr< Real > &	currentTime )

vizAnimMeteorMaterial() [2/2]

std::shared_ptr< Material > cil::vizAnimMeteorMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	length,
		const std::shared_ptr< Real > &	currentTime )

vizAnimMeteorScalarFragment()

std::shared_ptr< FragmentSource > cil::vizAnimMeteorScalarFragment

(

)

vizAnimRibbonColorFragment()

std::shared_ptr< FragmentSource > cil::vizAnimRibbonColorFragment

(

)

vizAnimRibbonColorGeometry()

std::shared_ptr< GeometrySource > cil::vizAnimRibbonColorGeometry

(

)

vizAnimRibbonMaterial() [1/2]

std::shared_ptr< Material > cil::vizAnimRibbonMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

vizAnimRibbonMaterial() [2/2]

std::shared_ptr< Material > cil::vizAnimRibbonMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

vizAnimRibbonScalarFragment()

std::shared_ptr< FragmentSource > cil::vizAnimRibbonScalarFragment

(

)

vizAnimRibbonScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizAnimRibbonScalarGeometry

(

)

vizAnimWidthColorFragment()

std::shared_ptr< FragmentSource > cil::vizAnimWidthColorFragment

(

)

vizAnimWidthColorGeometry()

std::shared_ptr< GeometrySource > cil::vizAnimWidthColorGeometry

(

)

vizAnimWidthMaterial() [1/2]

std::shared_ptr< Material > cil::vizAnimWidthMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

vizAnimWidthMaterial() [2/2]

std::shared_ptr< Material > cil::vizAnimWidthMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	currentTime )

vizAnimWidthScalarFragment()

std::shared_ptr< FragmentSource > cil::vizAnimWidthScalarFragment

(

)

vizAnimWidthScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizAnimWidthScalarGeometry

(

)

vizArrowColorVertex()

std::shared_ptr< VertexSource > cil::vizArrowColorVertex

(

)

vizArrowGeometry()

std::shared_ptr< Geometry > cil::vizArrowGeometry

(

)

vizArrowMaterial() [1/2]

std::shared_ptr< Material > cil::vizArrowMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizArrowMaterial() [2/2]

std::shared_ptr< Material > cil::vizArrowMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizArrowScalarVertex()

std::shared_ptr< VertexSource > cil::vizArrowScalarVertex

(

)

vizBallGeometry()

std::shared_ptr< Geometry > cil::vizBallGeometry

(

)

vizCloudColorFragment()

std::shared_ptr< FragmentSource > cil::vizCloudColorFragment

(

)

vizCloudColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizCloudColorOffsetVertex

(

)

vizCloudColorVertex()

std::shared_ptr< VertexSource > cil::vizCloudColorVertex

(

)

vizCloudMaterial() [1/2]

std::shared_ptr< Material > cil::vizCloudMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizCloudMaterial() [2/2]

std::shared_ptr< Material > cil::vizCloudMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizCloudOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizCloudOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizCloudOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizCloudOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizCloudScalarFragment()

std::shared_ptr< FragmentSource > cil::vizCloudScalarFragment

(

)

vizCloudScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizCloudScalarOffsetVertex

(

)

vizCloudScalarVertex()

std::shared_ptr< VertexSource > cil::vizCloudScalarVertex

(

)

vizCubeGeometry()

std::shared_ptr< Geometry > cil::vizCubeGeometry

(

)

vizCubeLineGeometry()

std::shared_ptr< Geometry > cil::vizCubeLineGeometry

(

)

vizCylinderColorFragment()

std::shared_ptr< FragmentSource > cil::vizCylinderColorFragment

(

)

vizCylinderColorGeometry()

std::shared_ptr< GeometrySource > cil::vizCylinderColorGeometry

(

)

vizCylinderMaterial() [1/2]

std::shared_ptr< Material > cil::vizCylinderMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width )

vizCylinderMaterial() [2/2]

std::shared_ptr< Material > cil::vizCylinderMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width )

vizCylinderOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizCylinderOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

vizCylinderOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizCylinderOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

vizCylinderScalarFragment()

std::shared_ptr< FragmentSource > cil::vizCylinderScalarFragment

(

)

vizCylinderScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizCylinderScalarGeometry

(

)

vizDeltaColorFragment()

std::shared_ptr< FragmentSource > cil::vizDeltaColorFragment

(

)

vizDeltaMaterial() [1/2]

std::shared_ptr< Material > cil::vizDeltaMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizDeltaMaterial() [2/2]

std::shared_ptr< Material > cil::vizDeltaMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizDeltaOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizDeltaOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizDeltaOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizDeltaOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizDeltaScalarFragment()

std::shared_ptr< FragmentSource > cil::vizDeltaScalarFragment

(

)

vizDiamondColorFragment()

std::shared_ptr< FragmentSource > cil::vizDiamondColorFragment

(

)

vizDiamondMaterial() [1/2]

std::shared_ptr< Material > cil::vizDiamondMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizDiamondMaterial() [2/2]

std::shared_ptr< Material > cil::vizDiamondMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizDiamondOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizDiamondOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizDiamondOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizDiamondOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizDiamondScalarFragment()

std::shared_ptr< FragmentSource > cil::vizDiamondScalarFragment

(

)

vizDiscColorFragment()

std::shared_ptr< FragmentSource > cil::vizDiscColorFragment

(

)

vizDiscMaterial() [1/2]

std::shared_ptr< Material > cil::vizDiscMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizDiscMaterial() [2/2]

std::shared_ptr< Material > cil::vizDiscMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizDiscOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizDiscOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizDiscOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizDiscOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizDiscScalarFragment()

std::shared_ptr< FragmentSource > cil::vizDiscScalarFragment

(

)

vizEnvironmentMappingColorFragment()

std::shared_ptr< FragmentSource > cil::vizEnvironmentMappingColorFragment

(

)

vizEnvironmentMappingColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizEnvironmentMappingColorOffsetVertex

(

)

vizEnvironmentMappingColorVertex()

std::shared_ptr< VertexSource > cil::vizEnvironmentMappingColorVertex

(

)

vizEnvironmentMappingMaterial() [1/2]

std::shared_ptr< Material > cil::vizEnvironmentMappingMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< ImageCube > &	envMappingImage )

vizEnvironmentMappingMaterial() [2/2]

std::shared_ptr< Material > cil::vizEnvironmentMappingMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< ImageCube > &	envMappingImage )

vizEnvironmentMappingOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizEnvironmentMappingOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< ImageCube > &	envMappingImage,
		const std::shared_ptr< Real > &	factor )

vizEnvironmentMappingOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizEnvironmentMappingOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< ImageCube > &	envMappingImage,
		const std::shared_ptr< Real > &	factor )

vizEnvironmentMappingScalarFragment()

std::shared_ptr< FragmentSource > cil::vizEnvironmentMappingScalarFragment

(

)

vizEnvironmentMappingScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizEnvironmentMappingScalarOffsetVertex

(

)

vizEnvironmentMappingScalarVertex()

std::shared_ptr< VertexSource > cil::vizEnvironmentMappingScalarVertex

(

)

vizFixedArrowColorVertex()

std::shared_ptr< VertexSource > cil::vizFixedArrowColorVertex

(

)

vizFixedArrowMaterial() [1/2]

std::shared_ptr< Material > cil::vizFixedArrowMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizFixedArrowMaterial() [2/2]

std::shared_ptr< Material > cil::vizFixedArrowMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizFixedArrowScalarVertex()

std::shared_ptr< VertexSource > cil::vizFixedArrowScalarVertex

(

)

vizFixedSphereColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizFixedSphereColorOffsetVertex

(

)

vizFixedSphereColorVertex()

std::shared_ptr< VertexSource > cil::vizFixedSphereColorVertex

(

)

vizFixedSphereMaterial() [1/2]

std::shared_ptr< Material > cil::vizFixedSphereMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizFixedSphereMaterial() [2/2]

std::shared_ptr< Material > cil::vizFixedSphereMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizFixedSphereOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizFixedSphereOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizFixedSphereOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizFixedSphereOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizFixedSphereScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizFixedSphereScalarOffsetVertex

(

)

vizFixedSphereScalarVertex()

std::shared_ptr< VertexSource > cil::vizFixedSphereScalarVertex

(

)

vizFlatColorFragment()

std::shared_ptr< FragmentSource > cil::vizFlatColorFragment

(

)

vizFlatColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizFlatColorOffsetVertex

(

)

vizFlatColorVertex()

std::shared_ptr< VertexSource > cil::vizFlatColorVertex

(

)

vizFlatMaterial() [1/2]

std::shared_ptr< Material > cil::vizFlatMaterial

(

const std::shared_ptr< Color4f > &

color

)

vizFlatMaterial() [2/2]

std::shared_ptr< Material > cil::vizFlatMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

vizFlatOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizFlatOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizFlatOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizFlatOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizFlatScalarFragment()

std::shared_ptr< FragmentSource > cil::vizFlatScalarFragment

(

)

vizFlatScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizFlatScalarOffsetVertex

(

)

vizFlatScalarVertex()

std::shared_ptr< VertexSource > cil::vizFlatScalarVertex

(

)

vizGlyphCulling()

std::shared_ptr< Culling > cil::vizGlyphCulling

(

)

vizInstanceColorVertex()

std::shared_ptr< VertexSource > cil::vizInstanceColorVertex

(

)

vizInstanceFragment()

std::shared_ptr< FragmentSource > cil::vizInstanceFragment

(

)

vizInstanceLineMaterial()

std::shared_ptr< Material > cil::vizInstanceLineMaterial

(

const std::shared_ptr< Real > &

factor

)

vizInstanceScalarVertex()

std::shared_ptr< VertexSource > cil::vizInstanceScalarVertex

(

)

vizInstanceShadedMaterial() [1/2]

std::shared_ptr< Material > cil::vizInstanceShadedMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizInstanceShadedMaterial() [2/2]

std::shared_ptr< Material > cil::vizInstanceShadedMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizInstanceUnlightVertex()

std::shared_ptr< VertexSource > cil::vizInstanceUnlightVertex

(

)

vizNormalFragment()

std::shared_ptr< FragmentSource > cil::vizNormalFragment

(

)

vizNormalMaterial()

std::shared_ptr< Material > cil::vizNormalMaterial

(

)

vizNormalOffsetMaterial()

std::shared_ptr< Material > cil::vizNormalOffsetMaterial

(

const std::shared_ptr< Real > &

factor

)

vizNormalOffsetVertex()

std::shared_ptr< VertexSource > cil::vizNormalOffsetVertex

(

)

vizNormalVertex()

std::shared_ptr< VertexSource > cil::vizNormalVertex

(

)

vizOpaqueDepth()

std::shared_ptr< Depth > cil::vizOpaqueDepth

(

)

vizOpaquePolygonOffset()

std::shared_ptr< PolygonOffset > cil::vizOpaquePolygonOffset

(

)

vizPointSprites()

std::shared_ptr< Point > cil::vizPointSprites

(

)

vizPositionFragment()

std::shared_ptr< FragmentSource > cil::vizPositionFragment

(

)

vizPositionMaterial()

std::shared_ptr< Material > cil::vizPositionMaterial

(

)

vizPositionOffsetMaterial()

std::shared_ptr< Material > cil::vizPositionOffsetMaterial

(

const std::shared_ptr< Real > &

factor

)

vizPositionOffsetVertex()

std::shared_ptr< VertexSource > cil::vizPositionOffsetVertex

(

)

vizPositionVertex()

std::shared_ptr< VertexSource > cil::vizPositionVertex

(

)

vizPtclFixedSphereColorVertex()

std::shared_ptr< VertexSource > cil::vizPtclFixedSphereColorVertex

(

)

vizPtclFixedSphereMaterial() [1/2]

std::shared_ptr< Material > cil::vizPtclFixedSphereMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

vizPtclFixedSphereMaterial() [2/2]

std::shared_ptr< Material > cil::vizPtclFixedSphereMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

vizPtclFixedSphereScalarVertex()

std::shared_ptr< VertexSource > cil::vizPtclFixedSphereScalarVertex

(

)

vizPtclSphereColorFragment()

std::shared_ptr< FragmentSource > cil::vizPtclSphereColorFragment

(

)

vizPtclSphereColorVertex()

std::shared_ptr< VertexSource > cil::vizPtclSphereColorVertex

(

)

vizPtclSphereMaterial() [1/2]

std::shared_ptr< Material > cil::vizPtclSphereMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

vizPtclSphereMaterial() [2/2]

std::shared_ptr< Material > cil::vizPtclSphereMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	currentTime )

vizPtclSphereScalarFragment()

std::shared_ptr< FragmentSource > cil::vizPtclSphereScalarFragment

(

)

vizPtclSphereScalarVertex()

std::shared_ptr< VertexSource > cil::vizPtclSphereScalarVertex

(

)

vizRectColorFragment()

std::shared_ptr< FragmentSource > cil::vizRectColorFragment

(

)

vizRectMaterial() [1/2]

std::shared_ptr< Material > cil::vizRectMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizRectMaterial() [2/2]

std::shared_ptr< Material > cil::vizRectMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizRectOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizRectOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizRectOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizRectOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizRectScalarFragment()

std::shared_ptr< FragmentSource > cil::vizRectScalarFragment

(

)

vizRibbonColorFragment()

std::shared_ptr< FragmentSource > cil::vizRibbonColorFragment

(

)

vizRibbonColorGeometry()

std::shared_ptr< GeometrySource > cil::vizRibbonColorGeometry

(

)

vizRibbonMaterial() [1/2]

std::shared_ptr< Material > cil::vizRibbonMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width )

vizRibbonMaterial() [2/2]

std::shared_ptr< Material > cil::vizRibbonMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width )

vizRibbonOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizRibbonOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

vizRibbonOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizRibbonOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

vizRibbonScalarFragment()

std::shared_ptr< FragmentSource > cil::vizRibbonScalarFragment

(

)

vizRibbonScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizRibbonScalarGeometry

(

)

vizRingColorFragment()

std::shared_ptr< FragmentSource > cil::vizRingColorFragment

(

)

vizRingMaterial() [1/2]

std::shared_ptr< Material > cil::vizRingMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizRingMaterial() [2/2]

std::shared_ptr< Material > cil::vizRingMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizRingOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizRingOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizRingOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizRingOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizRingScalarFragment()

std::shared_ptr< FragmentSource > cil::vizRingScalarFragment

(

)

vizRoseColorFragment()

std::shared_ptr< FragmentSource > cil::vizRoseColorFragment

(

)

vizRoseMaterial() [1/2]

std::shared_ptr< Material > cil::vizRoseMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizRoseMaterial() [2/2]

std::shared_ptr< Material > cil::vizRoseMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizRoseOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizRoseOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizRoseOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizRoseOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizRoseScalarFragment()

std::shared_ptr< FragmentSource > cil::vizRoseScalarFragment

(

)

vizScalarSampler()

std::shared_ptr< Sampler > cil::vizScalarSampler

(

)

vizShadedColorFragment()

std::shared_ptr< FragmentSource > cil::vizShadedColorFragment

(

)

vizShadedColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizShadedColorOffsetVertex

(

)

vizShadedColorVertex()

std::shared_ptr< VertexSource > cil::vizShadedColorVertex

(

)

vizShadedMaterial() [1/2]

std::shared_ptr< Material > cil::vizShadedMaterial

(

const std::shared_ptr< Color4f > &

color

)

vizShadedMaterial() [2/2]

std::shared_ptr< Material > cil::vizShadedMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

vizShadedOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizShadedOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizShadedOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizShadedOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizShadedScalarFragment()

std::shared_ptr< FragmentSource > cil::vizShadedScalarFragment

(

)

vizShadedScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizShadedScalarOffsetVertex

(

)

vizShadedScalarVertex()

std::shared_ptr< VertexSource > cil::vizShadedScalarVertex

(

)

vizShrinkColorFragment()

std::shared_ptr< FragmentSource > cil::vizShrinkColorFragment

(

)

vizShrinkColorGeometry()

std::shared_ptr< GeometrySource > cil::vizShrinkColorGeometry

(

)

vizShrinkMaterial() [1/2]

std::shared_ptr< Material > cil::vizShrinkMaterial

(

const std::shared_ptr< Color4f > &

color

)

vizShrinkMaterial() [2/2]

std::shared_ptr< Material > cil::vizShrinkMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

vizShrinkOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizShrinkOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizShrinkOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizShrinkOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizShrinkScalarFragment()

std::shared_ptr< FragmentSource > cil::vizShrinkScalarFragment

(

)

vizShrinkScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizShrinkScalarGeometry

(

)

vizSphereColorFragment()

std::shared_ptr< FragmentSource > cil::vizSphereColorFragment

(

)

vizSphereColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizSphereColorOffsetVertex

(

)

vizSphereColorVertex()

std::shared_ptr< VertexSource > cil::vizSphereColorVertex

(

)

vizSphereMaterial() [1/2]

std::shared_ptr< Material > cil::vizSphereMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizSphereMaterial() [2/2]

std::shared_ptr< Material > cil::vizSphereMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizSphereOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizSphereOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizSphereOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizSphereOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizSpherePoint()

std::shared_ptr< Point > cil::vizSpherePoint

(

)

vizSphereScalarFragment()

std::shared_ptr< FragmentSource > cil::vizSphereScalarFragment

(

)

vizSphereScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizSphereScalarOffsetVertex

(

)

vizSphereScalarVertex()

std::shared_ptr< VertexSource > cil::vizSphereScalarVertex

(

)

vizSpiralColorFragment()

std::shared_ptr< FragmentSource > cil::vizSpiralColorFragment

(

)

vizSpiralMaterial() [1/2]

std::shared_ptr< Material > cil::vizSpiralMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizSpiralMaterial() [2/2]

std::shared_ptr< Material > cil::vizSpiralMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizSpiralOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizSpiralOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizSpiralOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizSpiralOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizSpiralScalarFragment()

std::shared_ptr< FragmentSource > cil::vizSpiralScalarFragment

(

)

vizSquareColorFragment()

std::shared_ptr< FragmentSource > cil::vizSquareColorFragment

(

)

vizSquareMaterial() [1/2]

std::shared_ptr< Material > cil::vizSquareMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizSquareMaterial() [2/2]

std::shared_ptr< Material > cil::vizSquareMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizSquareOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizSquareOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizSquareOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizSquareOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizSquareScalarFragment()

std::shared_ptr< FragmentSource > cil::vizSquareScalarFragment

(

)

vizStarColorFragment()

std::shared_ptr< FragmentSource > cil::vizStarColorFragment

(

)

vizStarMaterial() [1/2]

std::shared_ptr< Material > cil::vizStarMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize )

vizStarMaterial() [2/2]

std::shared_ptr< Material > cil::vizStarMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize )

vizStarOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizStarOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizStarOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizStarOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	pointSize,
		const std::shared_ptr< Real > &	factor )

vizStarScalarFragment()

std::shared_ptr< FragmentSource > cil::vizStarScalarFragment

(

)

vizStripColorFragment()

std::shared_ptr< FragmentSource > cil::vizStripColorFragment

(

)

vizStripMaterial() [1/2]

std::shared_ptr< Material > cil::vizStripMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Integer > &	strips )

vizStripMaterial() [2/2]

std::shared_ptr< Material > cil::vizStripMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Integer > &	strips )

vizStripOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizStripOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Integer > &	strips,
		const std::shared_ptr< Real > &	factor )

vizStripOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizStripOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Integer > &	strips,
		const std::shared_ptr< Real > &	factor )

vizStripScalarFragment()

std::shared_ptr< FragmentSource > cil::vizStripScalarFragment

(

)

vizTransparentBlend()

std::shared_ptr< Blend > cil::vizTransparentBlend

(

)

vizTransparentColorFragment()

std::shared_ptr< FragmentSource > cil::vizTransparentColorFragment

(

)

vizTransparentDepth()

std::shared_ptr< Depth > cil::vizTransparentDepth

(

)

vizTransparentMaterial() [1/2]

std::shared_ptr< Material > cil::vizTransparentMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	alpha )

vizTransparentMaterial() [2/2]

std::shared_ptr< Material > cil::vizTransparentMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	alpha )

vizTransparentOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizTransparentOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	alpha,
		const std::shared_ptr< Real > &	factor )

vizTransparentOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizTransparentOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	alpha,
		const std::shared_ptr< Real > &	factor )

vizTransparentPolygonOffset()

std::shared_ptr< PolygonOffset > cil::vizTransparentPolygonOffset

(

)

vizTransparentScalarFragment()

std::shared_ptr< FragmentSource > cil::vizTransparentScalarFragment

(

)

vizUnlightColorFragment()

std::shared_ptr< FragmentSource > cil::vizUnlightColorFragment

(

)

vizUnlightColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizUnlightColorOffsetVertex

(

)

vizUnlightColorVertex()

std::shared_ptr< VertexSource > cil::vizUnlightColorVertex

(

)

vizUnlightMaterial() [1/2]

std::shared_ptr< Material > cil::vizUnlightMaterial

(

const std::shared_ptr< Color4f > &

color

)

vizUnlightMaterial() [2/2]

std::shared_ptr< Material > cil::vizUnlightMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range )

vizUnlightOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizUnlightOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	factor )

vizUnlightOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizUnlightOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	factor )

vizUnlightScalarFragment()

std::shared_ptr< FragmentSource > cil::vizUnlightScalarFragment

(

)

vizUnlightScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizUnlightScalarOffsetVertex

(

)

vizUnlightScalarVertex()

std::shared_ptr< VertexSource > cil::vizUnlightScalarVertex

(

)

vizWidthLineColorFragment()

std::shared_ptr< FragmentSource > cil::vizWidthLineColorFragment

(

)

vizWidthLineColorGeometry()

std::shared_ptr< GeometrySource > cil::vizWidthLineColorGeometry

(

)

vizWidthLineColorOffsetVertex()

std::shared_ptr< VertexSource > cil::vizWidthLineColorOffsetVertex

(

)

vizWidthLineColorVertex()

std::shared_ptr< VertexSource > cil::vizWidthLineColorVertex

(

)

vizWidthLineMaterial() [1/2]

std::shared_ptr< Material > cil::vizWidthLineMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width )

vizWidthLineMaterial() [2/2]

std::shared_ptr< Material > cil::vizWidthLineMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width )

vizWidthLineOffsetMaterial() [1/2]

std::shared_ptr< Material > cil::vizWidthLineOffsetMaterial	(	const std::shared_ptr< Color4f > &	color,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

vizWidthLineOffsetMaterial() [2/2]

std::shared_ptr< Material > cil::vizWidthLineOffsetMaterial	(	const std::shared_ptr< Image2D > &	image,
		const std::shared_ptr< MinMax > &	range,
		const std::shared_ptr< Real > &	width,
		const std::shared_ptr< Real > &	factor )

vizWidthLineScalarFragment()

std::shared_ptr< FragmentSource > cil::vizWidthLineScalarFragment

(

)

vizWidthLineScalarGeometry()

std::shared_ptr< GeometrySource > cil::vizWidthLineScalarGeometry

(

)

vizWidthLineScalarOffsetVertex()

std::shared_ptr< VertexSource > cil::vizWidthLineScalarOffsetVertex

(

)

vizWidthLineScalarVertex()

std::shared_ptr< VertexSource > cil::vizWidthLineScalarVertex

(

)

zoom() [1/2]

void cil::zoom	(	const std::shared_ptr< Camera > &	camera,
		const float	factor )

zoom() [2/2]

void cil::zoom	(	const std::shared_ptr< Camera > &	camera,
		const float	factor,
		const Vector3f &	offset )