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	BlockAttributes

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	CrinkleClip

class	CrinkleClipParameters

class	CrinkleSlice

class	CrinkleSliceParameters

class	CrinkleSolid

class	CrinkleSolidParameters

class	Culling
	The Culling class inherits from the base class State, describing the culling operation during rendering a 3D object. More...

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	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	IsoVolume

class	IsoVolumeParameters

class	Legend

class	LegendPass

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	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	PointAttributes

class	PointCloud

class	PointCloudParameters

class	PointParameters

class	Polygon
	The Polygon class inherits from the base class State, defining mode of Polygon. More...

class	PolygonAttributes

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	Solid

class	SolidParameters

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	TracerAttributes

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	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	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	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>

using	ParametersPtr = std::shared_ptr<Parameters>

using	FringeSurfaceParametersPtr = std::shared_ptr<FringeSurfaceParameters>

using	PolygonSurfaceParametersPtr = std::shared_ptr<PolygonSurfaceParameters>

using	SliceParametersPtr = std::shared_ptr<SliceParameters>

using	CrinkleSliceParametersPtr = std::shared_ptr<CrinkleSliceParameters>

using	ClipParametersPtr = std::shared_ptr<ClipParameters>

using	CrinkleClipParametersPtr = std::shared_ptr<CrinkleClipParameters>

using	ContourParametersPtr = std::shared_ptr<ContourParameters>

using	ThresholdParametersPtr = std::shared_ptr<ThresholdParameters>

using	IsoVolumeParametersPtr = std::shared_ptr<IsoVolumeParameters>

using	StreamTracerParametersPtr = std::shared_ptr<StreamTracerParameters>

using	StreamSurfaceParametersPtr = std::shared_ptr<StreamSurfaceParameters>

using	TubeParametersPtr = std::shared_ptr<TubeParameters>

using	RibbonParametersPtr = std::shared_ptr<RibbonParameters>

using	PointParametersPtr = std::shared_ptr<PointParameters>

using	SolidParametersPtr = std::shared_ptr<SolidParameters>

using	CrinkleSolidParametersPtr = std::shared_ptr<CrinkleSolidParameters>

using	PointCloudParametersPtr = std::shared_ptr<PointCloudParameters>

using	AttributesPtr = std::shared_ptr<Attributes>

using	PolygonAttributesPtr = std::shared_ptr<PolygonAttributes>

using	PartAttributesPtr = std::shared_ptr<PartAttributes>

using	TracerAttributesPtr = std::shared_ptr<TracerAttributes>

using	PointAttributesPtr = std::shared_ptr<PointAttributes>

using	BlockAttributesPtr = std::shared_ptr<BlockAttributes>

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	CrinkleSlicePtr = std::shared_ptr<CrinkleSlice>

using	ClipPtr = std::shared_ptr<Clip>

using	CrinkleClipPtr = std::shared_ptr<CrinkleClip>

using	ContourPtr = std::shared_ptr<Contour>

using	ThresholdPtr = std::shared_ptr<Threshold>

using	IsoVolumePtr = std::shared_ptr<IsoVolume>

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	BlockPtr = std::shared_ptr<Block>

using	SolidPtr = std::shared_ptr<Solid>

using	CrinkleSolidPtr = std::shared_ptr<CrinkleSolid>

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	VizPartPtrArray = std::vector<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 ()

std::shared_ptr< Vertices >	_vertices (const std::shared_ptr< Float32Array > &buffer, int offset=0, unsigned int stride=0, unsigned int divisor=0)

std::shared_ptr< Vertices >	_vertices (const std::shared_ptr< Int32Array > &buffer, int offset=0, unsigned int stride=0, unsigned int divisor=0)

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

std::shared_ptr< ArrayIndices >	_arrayIndices (Indices::Mode mode, int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_triangles (int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_triangle_fan (int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_triangle_strip (int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_lines (int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_line_strip (int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_line_loop (int count, int first=0, int primCount=0)

std::shared_ptr< ArrayIndices >	_points (int count, int first=0, int primCount=0)

std::shared_ptr< ElementIndices >	_elementIndices (Indices::Mode mode, const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_elementIndices (Indices::Mode mode, const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_elementIndices (Indices::Mode mode, const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangles (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangles (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangles (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< ElementIndices >	_triangle_fan (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangle_fan (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangle_fan (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< ElementIndices >	_triangle_strip (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangle_strip (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_triangle_strip (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< ElementIndices >	_lines (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_lines (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_lines (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< ElementIndices >	_line_strip (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_line_strip (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_line_strip (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< ElementIndices >	_line_loop (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_line_loop (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_line_loop (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< ElementIndices >	_points (const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_points (const std::shared_ptr< Uint16Array > &buffer, int count=-1, int offset=0, int primCount=0)

std::shared_ptr< ElementIndices >	_points (const std::shared_ptr< Uint32Array > &buffer, int count=-1, int offset=0, int primCount=0)

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

std::shared_ptr< std::map< std::string, std::shared_ptr< Vertices > > >	_verticesSet (const std::map< std::string, std::shared_ptr< Vertices > > &verticesMap={})

std::shared_ptr< Geometry >	_geometry (const std::shared_ptr< std::map< std::string, std::shared_ptr< Vertices > > > &verticesSet=_verticesSet(), const std::shared_ptr< Indices > &indices=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)

std::shared_ptr< Geometry >	_geometry (std::map< std::string, std::shared_ptr< Vertices > > verticesSet, const std::shared_ptr< Indices > &indices=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)

std::shared_ptr< Geometry >	_geometry (const std::shared_ptr< Indices > &indices, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)

std::shared_ptr< Blend >	_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)

std::shared_ptr< ColorMask >	_colorMask (bool red=true, bool green=true, bool blue=true, bool alpha=true)

std::shared_ptr< Culling >	_culling (bool enabled=false, Culling::Face face=Culling::Face::CCW, Culling::Mode mode=Culling::Mode::BACK)

std::shared_ptr< Depth >	_depth (bool enabled=false, Depth::Function func=Depth::Function::LESS, bool writeMask=true)

std::shared_ptr< Line >	_line (float width=1.0f)

std::shared_ptr< Point >	_point (float size=1.0f, bool programmable=false)

std::shared_ptr< Polygon >	_polygon (Polygon::Mode mode=Polygon::Mode::FILL)

std::shared_ptr< PolygonOffset >	_polygonOffset (bool enabled=false, float factor=0.0f, float units=0.0f)

std::shared_ptr< Scissor >	_scissor (bool enabled=false, int x=0, int y=0, int width=0, int height=0)

std::shared_ptr< Stencil >	_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)

std::shared_ptr< Sampler >	_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)

std::shared_ptr< Sampler >	_samplerClamp ()

std::shared_ptr< Sampler >	_samplerRepeat ()

std::shared_ptr< Sampler >	_samplerMirror ()

std::shared_ptr< Sampler >	_samplerCube ()

std::shared_ptr< Texture >	_texture (int unit, const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture0 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture1 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture2 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture3 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture4 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture5 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture6 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Texture >	_texture7 (const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)

std::shared_ptr< Program >	_program (const std::shared_ptr< VertexSource > &vertex=nullptr, const std::shared_ptr< FragmentSource > &fragment=nullptr, const std::shared_ptr< GeometrySource > &geometry=nullptr)

std::shared_ptr< Program >	_program (const std::shared_ptr< FragmentSource > &fragment, const std::shared_ptr< GeometrySource > &geometry=nullptr)

std::shared_ptr< Program >	_program (const std::shared_ptr< GeometrySource > &geometry)

std::shared_ptr< Program >	_program (const std::string &vertexString)

std::shared_ptr< Program >	_program (const std::string &vertexString, const std::string &fragmentString)

std::shared_ptr< Program >	_program (const std::string &vertexString, const std::string &fragmentString, const std::string &geometryString)

std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > >	_parameters (const std::map< std::string, std::shared_ptr< Variant > > &parameters={})

std::shared_ptr< std::vector< std::shared_ptr< State > > >	_states (const std::vector< std::shared_ptr< State > > &states={})

std::shared_ptr< Material >	_material (const std::shared_ptr< Program > &program=nullptr, const std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > > &parameters=nullptr, const std::shared_ptr< std::vector< std::shared_ptr< State > > > &states=nullptr)

std::shared_ptr< Material >	_material (const std::shared_ptr< Program > &program, const std::shared_ptr< std::vector< std::shared_ptr< State > > > &states)

std::shared_ptr< Material >	_material (const std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > > &parameters, const std::shared_ptr< std::vector< std::shared_ptr< State > > > &states=nullptr)

std::shared_ptr< Material >	_material (const std::vector< std::shared_ptr< Source > > &sources, const std::map< std::string, std::shared_ptr< Variant > > &parameters, const std::vector< std::shared_ptr< State > > &states)

std::shared_ptr< Material >	_material (const std::vector< std::shared_ptr< Source > > &sources, const std::map< std::string, std::shared_ptr< Variant > > &parameters)

std::shared_ptr< Material >	_material (const std::vector< std::shared_ptr< Source > > &sources, const std::vector< std::shared_ptr< State > > &states)

std::shared_ptr< Material >	_material (const std::vector< std::shared_ptr< Source > > &sources)

std::shared_ptr< Material >	_material (const std::shared_ptr< Program > &program, const std::map< std::string, std::shared_ptr< Variant > > &parameters, const std::vector< std::shared_ptr< State > > &states)

std::shared_ptr< Material >	_material (const std::shared_ptr< Program > &program, const std::map< std::string, std::shared_ptr< Variant > > &parameters)

std::shared_ptr< Material >	_material (const std::shared_ptr< Program > &program, const std::vector< std::shared_ptr< State > > &states)

std::shared_ptr< Material >	_material (const std::map< std::string, std::shared_ptr< Variant > > &parameters, const std::vector< std::shared_ptr< State > > &states)

std::shared_ptr< Material >	_material (const std::map< std::string, std::shared_ptr< Variant > > &parameters)

std::shared_ptr< Material >	_material (const std::vector< std::shared_ptr< State > > &states)

std::shared_ptr< Background >	_background (const std::shared_ptr< Vector2i > &size, const std::shared_ptr< Color4f > &colorMask=nullptr, const std::shared_ptr< Real > &depthMask=nullptr, const std::shared_ptr< Integer > &stencilMask=nullptr, const std::shared_ptr< Vector2i > &coordinate=_ivec2())

std::shared_ptr< Background >	_simpleBackground (const std::shared_ptr< Vector2i > &size, const std::shared_ptr< Color4f > &colorMask=_clr4(0.7, 0.7, 0.7, 1.0), const std::shared_ptr< Real > &depthMask=_real(1.0), const std::shared_ptr< Integer > &stencilMask=nullptr, const std::shared_ptr< Vector2i > &coordinate=_ivec2())

std::shared_ptr< ImageBuffer >	_colorBuf ()

std::shared_ptr< Target >	_target ()

std::shared_ptr< Target >	_target (const std::vector< std::shared_ptr< ImageBuffer > > &array)

std::shared_ptr< Primitive >	_primitive (const std::shared_ptr< Geometry > &geometry=nullptr, const std::shared_ptr< Material > &material=nullptr, int priority=0)

std::shared_ptr< Primitive >	_primitive (const std::shared_ptr< Material > &material, int priority=0)

std::shared_ptr< Camera >	_camera (const std::shared_ptr< Matrix4f > &viewMatrix=_mat4(), const std::shared_ptr< Matrix4f > &projectionMatrix=_mat4(), const std::shared_ptr< Vector3f > &orbitPoint=_vec3())

std::shared_ptr< std::vector< std::shared_ptr< Primitive > > >	_primitives (const std::vector< std::shared_ptr< Primitive > > &primitives={})

std::shared_ptr< Mesh >	_mesh (const std::shared_ptr< std::vector< std::shared_ptr< Primitive > > > &primitives=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)

std::shared_ptr< Mesh >	_mesh (const std::vector< std::shared_ptr< Primitive > > &primitives, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)

std::shared_ptr< Node >	_node (const std::shared_ptr< Mesh > &mesh=nullptr, const std::shared_ptr< std::vector< std::shared_ptr< Node > > > &children=nullptr, const std::shared_ptr< Matrix4f > &transform=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr, const std::string &name="Node", const std::shared_ptr< Material > &material=nullptr, const std::shared_ptr< Geometry > &geometry=nullptr, const std::shared_ptr< Query > &query=nullptr)

std::shared_ptr< Node >	_node (const std::shared_ptr< std::vector< std::shared_ptr< Node > > > &children, const std::shared_ptr< Matrix4f > &transform=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr, const std::string &name="Node", const std::shared_ptr< Material > &material=nullptr, const std::shared_ptr< Geometry > &geometry=nullptr, const std::shared_ptr< Query > &query=nullptr)

std::shared_ptr< Node >	_node (const std::vector< std::shared_ptr< Primitive > > &primitives, const std::shared_ptr< Matrix4f > &transform=nullptr)

std::shared_ptr< Node >	_node (const std::vector< std::shared_ptr< Node > > &nodes, const std::shared_ptr< Matrix4f > &transform=nullptr)

std::shared_ptr< Node >	_node (const std::vector< std::shared_ptr< Primitive > > &primitives, const std::vector< std::shared_ptr< Node > > &nodes, const std::shared_ptr< Matrix4f > &transform=nullptr)

std::shared_ptr< std::vector< std::shared_ptr< Node > > >	_nodes (const std::vector< std::shared_ptr< Node > > &nodes={})

std::shared_ptr< Pass >	_pass (const std::shared_ptr< Node > &node=nullptr, const std::shared_ptr< Background > &background=nullptr, const std::shared_ptr< Camera > &camera=nullptr, const std::shared_ptr< Target > &target=nullptr, const std::string &name="Pass", bool enabled=true)

std::shared_ptr< Scene >	_scene (const std::shared_ptr< std::vector< std::shared_ptr< Pass > > > &passes=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr, const std::string &name="Scene")

std::shared_ptr< Scene >	_scene (const std::vector< std::shared_ptr< Pass > > &passes, const std::shared_ptr< BoundingBox > &boundingBox=nullptr, const std::string &name="Scene")

std::shared_ptr< Box2i >	_box2i ()

std::shared_ptr< Box2i >	_box2i (int xmin, int xmax, int ymin, int ymax)

std::shared_ptr< Box2i >	_box2i (const Vector2i &min, const Vector2i &max)

std::shared_ptr< Box2i >	_box2i (const Box2i &other)

std::shared_ptr< Box2f >	_box2f ()

std::shared_ptr< Box2f >	_box2f (float xmin, float xmax, float ymin, float ymax)

std::shared_ptr< Box2f >	_box2f (const Vector2f &min, const Vector2f &max)

std::shared_ptr< Box2f >	_box2f (const Box2f &other)

std::shared_ptr< Box3i >	_box3i ()

std::shared_ptr< Box3i >	_box3i (int xmin, int xmax, int ymin, int ymax, int zmin, int zmax)

std::shared_ptr< Box3i >	_box3i (const Vector3i &min, const Vector3i &max)

std::shared_ptr< Box3i >	_box3i (const Box3i &other)

std::shared_ptr< Box3f >	_box3f ()

std::shared_ptr< Box3f >	_box3f (float xmin, float xmax, float ymin, float ymax, float zmin, float zmax)

std::shared_ptr< Box3f >	_box3f (const Vector3f &min, const Vector3f &max)

std::shared_ptr< Box3f >	_box3f (const Box3f &other)

std::shared_ptr< BoundingBox >	_bbox ()

std::shared_ptr< BoundingBox >	_bbox (float xmin, float xmax, float ymin, float ymax, float zmin, float zmax)

std::shared_ptr< BoundingBox >	_bbox (const Vector3f &min, const Vector3f &max)

std::shared_ptr< BoundingBox >	_bbox (const BoundingBox &other)

std::shared_ptr< Color3f >	_clr3 ()

std::shared_ptr< Color3f >	_clr3 (float r, float g, float b)

std::shared_ptr< Color3f >	_clr3 (const Color3f &other)

std::shared_ptr< Color3f >	_clr3 (const Color3ub &other)

std::shared_ptr< Color3f >	_clr3 (const Color4f &other)

std::shared_ptr< Color3f >	_clr3 (const Color4ub &other)

std::shared_ptr< Color3ub >	_clr3ub ()

std::shared_ptr< Color3ub >	_clr3ub (unsigned char r, unsigned char g, unsigned char b)

std::shared_ptr< Color3ub >	_clr3ub (const Color3f &other)

std::shared_ptr< Color3ub >	_clr3ub (const Color3ub &other)

std::shared_ptr< Color3ub >	_clr3ub (const Color4f &other)

std::shared_ptr< Color3ub >	_clr3ub (const Color4ub &other)

std::shared_ptr< Color4f >	_clr4 ()

std::shared_ptr< Color4f >	_clr4 (float r, float g, float b, float a)

std::shared_ptr< Color4f >	_clr4 (const Color3f &other)

std::shared_ptr< Color4f >	_clr4 (const Color3ub &other)

std::shared_ptr< Color4f >	_clr4 (const Color4f &other)

std::shared_ptr< Color4f >	_clr4 (const Color4ub &other)

std::shared_ptr< Color4ub >	_clr4ub ()

std::shared_ptr< Color4ub >	_clr4ub (unsigned char r, unsigned char g, unsigned char b, unsigned char a)

std::shared_ptr< Color4ub >	_clr4ub (const Color3f &other)

std::shared_ptr< Color4ub >	_clr4ub (const Color3ub &other)

std::shared_ptr< Color4ub >	_clr4ub (const Color4f &other)

std::shared_ptr< Color4ub >	_clr4ub (const Color4ub &other)

std::shared_ptr< Image2D >	_image2d (int width, int height, unsigned char *data=nullptr)

std::shared_ptr< ImageCube >	_imageCube (const std::vector< Image2D > &images)

std::shared_ptr< Integer >	_integer ()

std::shared_ptr< Integer >	_integer (int v)

std::shared_ptr< Integer >	_integer (const Integer &other)

std::shared_ptr< Matrix2f >	_mat2 ()

std::shared_ptr< Matrix2f >	_mat2 (float e00, float e01, float e10, float e11)

std::shared_ptr< Matrix2f >	_mat2 (const Vector2f &c0, const Vector2f &c1)

std::shared_ptr< Matrix2f >	_mat2 (const Matrix2f &other)

std::shared_ptr< Matrix2f >	_mat2 (const Matrix3f &other)

std::shared_ptr< Matrix2f >	_mat2 (const Matrix4f &other)

std::shared_ptr< Matrix3f >	_mat3 ()

std::shared_ptr< Matrix3f >	_mat3 (float e00, float e01, float e02, float e10, float e11, float e12, float e20, float e21, float e22)

std::shared_ptr< Matrix3f >	_mat3 (const Vector3f &c0, const Vector3f &c1, const Vector3f &c2)

std::shared_ptr< Matrix3f >	_mat3 (const Matrix2f &other)

std::shared_ptr< Matrix3f >	_mat3 (const Matrix3f &other)

std::shared_ptr< Matrix3f >	_mat3 (const Matrix4f &other)

std::shared_ptr< Matrix4f >	_mat4 ()

std::shared_ptr< Matrix4f >	_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)

std::shared_ptr< Matrix4f >	_mat4 (const Vector4f &c0, const Vector4f &c1, const Vector4f &c2, const Vector4f &c3)

std::shared_ptr< Matrix4f >	_mat4 (const Matrix2f &other)

std::shared_ptr< Matrix4f >	_mat4 (const Matrix3f &other)

std::shared_ptr< Matrix4f >	_mat4 (const Matrix4f &other)

std::shared_ptr< MinMax >	_minmax ()

std::shared_ptr< MinMax >	_minmax (float min, float max)

std::shared_ptr< MinMax >	_minmax (const MinMax &other)

std::shared_ptr< Plane >	_plane ()

std::shared_ptr< Plane >	_plane (float x, float y, float z, float w)

std::shared_ptr< Plane >	_plane (const Vector3f &origin, const Vector3f &normal)

std::shared_ptr< Plane >	_plane (const Plane &other)

std::shared_ptr< Quaternion >	_quat ()

std::shared_ptr< Quaternion >	_quat (float x, float y, float z, float w)

std::shared_ptr< Quaternion >	_quat (const Vector3f &axis, float angle)

std::shared_ptr< Quaternion >	_quat (const Quaternion &other)

std::shared_ptr< Ray >	_ray ()

std::shared_ptr< Ray >	_ray (const Vector3f &origin, const Vector3f &normal)

std::shared_ptr< Ray >	_ray (const Ray &other)

std::shared_ptr< Real >	_real ()

std::shared_ptr< Real >	_real (float v)

std::shared_ptr< Real >	_real (const Real &other)

std::shared_ptr< VertexSource >	_vert (const std::string &text)

std::shared_ptr< FragmentSource >	_frag (const std::string &text)

std::shared_ptr< GeometrySource >	_geom (const std::string &text)

std::shared_ptr< Int8Array >	_i8array (int size=0, char *data=nullptr, bool copy=true)

std::shared_ptr< Int8Array >	_i8array (const std::initializer_list< char > &array)

std::shared_ptr< Uint8Array >	_u8array (int size=0, unsigned char *data=nullptr, bool copy=true)

std::shared_ptr< Uint8Array >	_u8array (const std::initializer_list< unsigned char > &array)

std::shared_ptr< Int16Array >	_i16array (int size=0, short *data=nullptr, bool copy=true)

std::shared_ptr< Int16Array >	_i16array (const std::initializer_list< short > &array)

std::shared_ptr< Uint16Array >	_u16array (int size=0, unsigned short *data=nullptr, bool copy=true)

std::shared_ptr< Uint16Array >	_u16array (const std::initializer_list< unsigned short > &array)

std::shared_ptr< Int32Array >	_i32array (int size=0, int *data=nullptr, bool copy=true)

std::shared_ptr< Int32Array >	_i32array (const std::initializer_list< int > &array)

std::shared_ptr< Uint32Array >	_u32array (int size=0, unsigned int *data=nullptr, bool copy=true)

std::shared_ptr< Uint32Array >	_u32array (const std::initializer_list< unsigned int > &array)

std::shared_ptr< Float32Array >	_f32array (int size=0, float *data=nullptr, bool copy=true)

std::shared_ptr< Float32Array >	_f32array (const std::initializer_list< float > &array)

std::shared_ptr< Float64Array >	_f64array (int size=0, double *data=nullptr, bool copy=true)

std::shared_ptr< Float64Array >	_f64array (const std::initializer_list< double > &array)

std::shared_ptr< Vector2i >	_ivec2 ()

std::shared_ptr< Vector2i >	_ivec2 (int x, int y)

std::shared_ptr< Vector2i >	_ivec2 (const Vector2i &other)

std::shared_ptr< Vector2i >	_ivec2 (const Vector3i &other)

std::shared_ptr< Vector2i >	_ivec2 (const Vector4i &other)

std::shared_ptr< Vector2f >	_vec2 ()

std::shared_ptr< Vector2f >	_vec2 (float x, float y)

std::shared_ptr< Vector2f >	_vec2 (const Vector2f &other)

std::shared_ptr< Vector2f >	_vec2 (const Vector3f &other)

std::shared_ptr< Vector2f >	_vec2 (const Vector4f &other)

std::shared_ptr< Vector3i >	_ivec3 ()

std::shared_ptr< Vector3i >	_ivec3 (int x, int y, int z)

std::shared_ptr< Vector3i >	_ivec3 (const Vector2i &other, int z=0)

std::shared_ptr< Vector3i >	_ivec3 (const Vector3i &other)

std::shared_ptr< Vector3i >	_ivec3 (const Vector4i &other)

std::shared_ptr< Vector3f >	_vec3 ()

std::shared_ptr< Vector3f >	_vec3 (float x, float y, float z)

std::shared_ptr< Vector3f >	_vec3 (const Vector2f &other, float z=0)

std::shared_ptr< Vector3f >	_vec3 (const Vector3f &other)

std::shared_ptr< Vector3f >	_vec3 (const Vector4f &other)

std::shared_ptr< Vector4i >	_ivec4 ()

std::shared_ptr< Vector4i >	_ivec4 (int x, int y, int z, int w)

std::shared_ptr< Vector4i >	_ivec4 (const Vector2i &other, int z=0, int w=0)

std::shared_ptr< Vector4i >	_ivec4 (const Vector3i &other, int w=0)

std::shared_ptr< Vector4i >	_ivec4 (const Vector4i &other)

std::shared_ptr< Vector4f >	_vec4 ()

std::shared_ptr< Vector4f >	_vec4 (float x, float y, float z, float w)

std::shared_ptr< Vector4f >	_vec4 (const Vector2f &other, float z=0, float w=0)

std::shared_ptr< Vector4f >	_vec4 (const Vector3f &other, float w=0)

std::shared_ptr< Vector4f >	_vec4 (const Vector4f &other)

std::shared_ptr< Timer >	_timer ()

std::shared_ptr< BoundingBox >	getBoundingBox (const std::shared_ptr< Geometry > &geometry, const std::string &attribName="positions")

std::shared_ptr< BoundingBox >	getBoundingBox (const std::shared_ptr< Primitive > &primitive)

std::shared_ptr< BoundingBox >	getBoundingBox (const std::shared_ptr< Mesh > &mesh)

std::shared_ptr< BoundingBox >	getBoundingBox (const std::shared_ptr< Node > &node)

std::shared_ptr< BoundingBox >	getBoundingBox (const std::shared_ptr< Pass > &pass)

std::shared_ptr< BoundingBox >	getBoundingBox (const std::shared_ptr< Scene > &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 ParametersPtr &parameters)

VizPartPtrArray	extractDataModel (const DataModelPtr &dataModel, const ParametersPtr &parameters)

VizPartPtrArray	extractDataModelById (const DataSolutionPtr &dataSolution, int id, const ParametersPtr &parameters)

std::vector< std::shared_ptr< Primitive > >	generatePartArrayPrimitive (const VizPartPtrArray &vizParts, const AttributesPtr &attributes, const std::shared_ptr< ScenarioSettings > &settings)

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	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")

Typedef Documentation

◆ AttributesPtr

using cil::AttributesPtr = std::shared_ptr<Attributes>

◆ bbox

using cil::bbox = BoundingBox

◆ BlockAttributesPtr

using cil::BlockAttributesPtr = std::shared_ptr<BlockAttributes>

◆ BlockPtr

using cil::BlockPtr = std::shared_ptr<Block>

◆ box2

using cil::box2 = Box2f

◆ box3

using cil::box3 = Box3f

◆ ClipParametersPtr

using cil::ClipParametersPtr = std::shared_ptr<ClipParameters>

◆ 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

◆ ContourParametersPtr

using cil::ContourParametersPtr = std::shared_ptr<ContourParameters>

◆ ContourPtr

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

◆ CrinkleClipParametersPtr

using cil::CrinkleClipParametersPtr = std::shared_ptr<CrinkleClipParameters>

◆ CrinkleClipPtr

using cil::CrinkleClipPtr = std::shared_ptr<CrinkleClip>

◆ CrinkleSliceParametersPtr

using cil::CrinkleSliceParametersPtr = std::shared_ptr<CrinkleSliceParameters>

◆ CrinkleSlicePtr

using cil::CrinkleSlicePtr = std::shared_ptr<CrinkleSlice>

◆ CrinkleSolidParametersPtr

using cil::CrinkleSolidParametersPtr = std::shared_ptr<CrinkleSolidParameters>

◆ CrinkleSolidPtr

using cil::CrinkleSolidPtr = std::shared_ptr<CrinkleSolid>

◆ 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

◆ 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>

◆ frag

using cil::frag = FragmentSource

◆ FringeSurfaceParametersPtr

using cil::FringeSurfaceParametersPtr = std::shared_ptr<FringeSurfaceParameters>

◆ FringeSurfacePtr

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

◆ geom

using cil::geom = 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

◆ imageBuf

using cil::imageBuf = ImageBuffer

◆ imageCube

using cil::imageCube = ImageCube

◆ integer

using cil::integer = Integer

◆ IsoVolumeParametersPtr

using cil::IsoVolumeParametersPtr = std::shared_ptr<IsoVolumeParameters>

◆ IsoVolumePtr

using cil::IsoVolumePtr = std::shared_ptr<IsoVolume>

◆ ivec2

using cil::ivec2 = Vector2i

◆ ivec3

using cil::ivec3 = Vector3i

◆ ivec4

using cil::ivec4 = Vector4i

◆ mat2

using cil::mat2 = Matrix2f

◆ mat3

using cil::mat3 = Matrix3f

◆ mat4

using cil::mat4 = Matrix4f

◆ minmax

using cil::minmax = MinMax

◆ ParametersPtr

using cil::ParametersPtr = std::shared_ptr<Parameters>

◆ PartAttributesPtr

using cil::PartAttributesPtr = std::shared_ptr<PartAttributes>

◆ plane

using cil::plane = Plane

◆ PointAttributesPtr

using cil::PointAttributesPtr = std::shared_ptr<PointAttributes>

◆ PointCloudParametersPtr

using cil::PointCloudParametersPtr = std::shared_ptr<PointCloudParameters>

◆ PointCloudPtr

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

◆ PointParametersPtr

using cil::PointParametersPtr = std::shared_ptr<PointParameters>

◆ PolygonAttributesPtr

using cil::PolygonAttributesPtr = std::shared_ptr<PolygonAttributes>

◆ PolygonSurfaceParametersPtr

using cil::PolygonSurfaceParametersPtr = std::shared_ptr<PolygonSurfaceParameters>

◆ PolygonSurfacePtr

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

◆ ProbePtr

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

◆ quat

using cil::quat = Quaternion

◆ ray

using cil::ray = Ray

◆ real

using cil::real = Real

◆ RibbonParametersPtr

using cil::RibbonParametersPtr = std::shared_ptr<RibbonParameters>

◆ RibbonPtr

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

◆ SliceParametersPtr

using cil::SliceParametersPtr = std::shared_ptr<SliceParameters>

◆ SlicePtr

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

◆ SolidParametersPtr

using cil::SolidParametersPtr = std::shared_ptr<SolidParameters>

◆ SolidPtr

using cil::SolidPtr = std::shared_ptr<Solid>

◆ StreamSurfaceParametersPtr

using cil::StreamSurfaceParametersPtr = std::shared_ptr<StreamSurfaceParameters>

◆ StreamSurfacePtr

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

◆ StreamTracerParametersPtr

using cil::StreamTracerParametersPtr = std::shared_ptr<StreamTracerParameters>

◆ StreamTracerPtr

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

◆ ThresholdParametersPtr

using cil::ThresholdParametersPtr = std::shared_ptr<ThresholdParameters>

◆ ThresholdPtr

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

◆ TracerAttributesPtr

using cil::TracerAttributesPtr = std::shared_ptr<TracerAttributes>

◆ TubeParametersPtr

using cil::TubeParametersPtr = std::shared_ptr<TubeParameters>

◆ TubePtr

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

◆ u16array

using cil::u16array = Uint16Array

◆ u32array

using cil::u32array = Uint32Array

◆ u8array

using cil::u8array = Uint8Array

◆ vec2

using cil::vec2 = Vector2f

◆ vec3

using cil::vec3 = Vector3f

◆ vec4

using cil::vec4 = Vector4f

◆ vert

using cil::vert = VertexSource

◆ 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>

◆ VizPartPtrArray

using cil::VizPartPtrArray = std::vector<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()

std::shared_ptr< ArrayIndices > 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()

std::shared_ptr< Background > cil::_background	(	const std::shared_ptr< Vector2i > &	size,
		const std::shared_ptr< Color4f > &	colorMask = nullptr,
		const std::shared_ptr< Real > &	depthMask = nullptr,
		const std::shared_ptr< Integer > &	stencilMask = nullptr,
		const std::shared_ptr< Vector2i > &	coordinate = _ivec2() )

◆ _bbox() [1/4]

std::shared_ptr< BoundingBox > cil::_bbox ( )

◆ _bbox() [2/4]

std::shared_ptr< BoundingBox > cil::_bbox ( const BoundingBox & other )

◆ _bbox() [3/4]

std::shared_ptr< BoundingBox > cil::_bbox	(	const Vector3f &	min,
		const Vector3f &	max )

◆ _bbox() [4/4]

std::shared_ptr< BoundingBox > 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()

std::shared_ptr< Blend > 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]

std::shared_ptr< Box2f > cil::_box2f ( )

◆ _box2f() [2/4]

std::shared_ptr< Box2f > cil::_box2f ( const Box2f & other )

◆ _box2f() [3/4]

std::shared_ptr< Box2f > cil::_box2f	(	const Vector2f &	min,
		const Vector2f &	max )

◆ _box2f() [4/4]

std::shared_ptr< Box2f > cil::_box2f	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax )

◆ _box2i() [1/4]

std::shared_ptr< Box2i > cil::_box2i ( )

◆ _box2i() [2/4]

std::shared_ptr< Box2i > cil::_box2i ( const Box2i & other )

◆ _box2i() [3/4]

std::shared_ptr< Box2i > cil::_box2i	(	const Vector2i &	min,
		const Vector2i &	max )

◆ _box2i() [4/4]

std::shared_ptr< Box2i > cil::_box2i	(	int	xmin,
		int	xmax,
		int	ymin,
		int	ymax )

◆ _box3f() [1/4]

std::shared_ptr< Box3f > cil::_box3f ( )

◆ _box3f() [2/4]

std::shared_ptr< Box3f > cil::_box3f ( const Box3f & other )

◆ _box3f() [3/4]

std::shared_ptr< Box3f > cil::_box3f	(	const Vector3f &	min,
		const Vector3f &	max )

◆ _box3f() [4/4]

std::shared_ptr< Box3f > cil::_box3f	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax,
		float	zmin,
		float	zmax )

◆ _box3i() [1/4]

std::shared_ptr< Box3i > cil::_box3i ( )

◆ _box3i() [2/4]

std::shared_ptr< Box3i > cil::_box3i ( const Box3i & other )

◆ _box3i() [3/4]

std::shared_ptr< Box3i > cil::_box3i	(	const Vector3i &	min,
		const Vector3i &	max )

◆ _box3i() [4/4]

std::shared_ptr< Box3i > 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()

std::shared_ptr< Camera > cil::_camera	(	const std::shared_ptr< Matrix4f > &	viewMatrix = _mat4(),
		const std::shared_ptr< Matrix4f > &	projectionMatrix = _mat4(),
		const std::shared_ptr< Vector3f > &	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]

std::shared_ptr< Color3f > cil::_clr3 ( )

◆ _clr3() [2/6]

std::shared_ptr< Color3f > cil::_clr3 ( const Color3f & other )

◆ _clr3() [3/6]

std::shared_ptr< Color3f > cil::_clr3 ( const Color3ub & other )

◆ _clr3() [4/6]

std::shared_ptr< Color3f > cil::_clr3 ( const Color4f & other )

◆ _clr3() [5/6]

std::shared_ptr< Color3f > cil::_clr3 ( const Color4ub & other )

◆ _clr3() [6/6]

std::shared_ptr< Color3f > cil::_clr3	(	float	r,
		float	g,
		float	b )

◆ _clr3ub() [1/6]

std::shared_ptr< Color3ub > cil::_clr3ub ( )

◆ _clr3ub() [2/6]

std::shared_ptr< Color3ub > cil::_clr3ub ( const Color3f & other )

◆ _clr3ub() [3/6]

std::shared_ptr< Color3ub > cil::_clr3ub ( const Color3ub & other )

◆ _clr3ub() [4/6]

std::shared_ptr< Color3ub > cil::_clr3ub ( const Color4f & other )

◆ _clr3ub() [5/6]

std::shared_ptr< Color3ub > cil::_clr3ub ( const Color4ub & other )

◆ _clr3ub() [6/6]

std::shared_ptr< Color3ub > cil::_clr3ub	(	unsigned char	r,
		unsigned char	g,
		unsigned char	b )

◆ _clr4() [1/6]

std::shared_ptr< Color4f > cil::_clr4 ( )

◆ _clr4() [2/6]

std::shared_ptr< Color4f > cil::_clr4 ( const Color3f & other )

◆ _clr4() [3/6]

std::shared_ptr< Color4f > cil::_clr4 ( const Color3ub & other )

◆ _clr4() [4/6]

std::shared_ptr< Color4f > cil::_clr4 ( const Color4f & other )

◆ _clr4() [5/6]

std::shared_ptr< Color4f > cil::_clr4 ( const Color4ub & other )

◆ _clr4() [6/6]

std::shared_ptr< Color4f > cil::_clr4	(	float	r,
		float	g,
		float	b,
		float	a )

◆ _clr4ub() [1/6]

std::shared_ptr< Color4ub > cil::_clr4ub ( )

◆ _clr4ub() [2/6]

std::shared_ptr< Color4ub > cil::_clr4ub ( const Color3f & other )

◆ _clr4ub() [3/6]

std::shared_ptr< Color4ub > cil::_clr4ub ( const Color3ub & other )

◆ _clr4ub() [4/6]

std::shared_ptr< Color4ub > cil::_clr4ub ( const Color4f & other )

◆ _clr4ub() [5/6]

std::shared_ptr< Color4ub > cil::_clr4ub ( const Color4ub & other )

◆ _clr4ub() [6/6]

std::shared_ptr< Color4ub > cil::_clr4ub	(	unsigned char	r,
		unsigned char	g,
		unsigned char	b,
		unsigned char	a )

◆ _colorBuf()

std::shared_ptr< ImageBuffer > cil::_colorBuf ( )

◆ _colorGenerator()

std::shared_ptr< ColorGenerator > cil::_colorGenerator ( float hue = 0 )

◆ _colorMask()

std::shared_ptr< ColorMask > 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()

std::shared_ptr< Culling > 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()

std::shared_ptr< Depth > 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]

std::shared_ptr< ElementIndices > cil::_elementIndices	(	Indices::Mode	mode,
		const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _elementIndices() [2/3]

std::shared_ptr< ElementIndices > cil::_elementIndices	(	Indices::Mode	mode,
		const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _elementIndices() [3/3]

std::shared_ptr< ElementIndices > cil::_elementIndices	(	Indices::Mode	mode,
		const std::shared_ptr< Uint8Array > &	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]

std::shared_ptr< Float32Array > cil::_f32array ( const std::initializer_list< float > & array )

◆ _f32array() [2/2]

std::shared_ptr< Float32Array > cil::_f32array	(	int	size = 0,
		float *	data = nullptr,
		bool	copy = true )

◆ _f64array() [1/2]

std::shared_ptr< Float64Array > cil::_f64array ( const std::initializer_list< double > & array )

◆ _f64array() [2/2]

std::shared_ptr< Float64Array > 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()

std::shared_ptr< FragmentSource > 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()

std::shared_ptr< GeometrySource > cil::_geom ( const std::string & text )

◆ _geometry() [1/3]

std::shared_ptr< Geometry > cil::_geometry	(	const std::shared_ptr< Indices > &	indices,
		const std::shared_ptr< BoundingBox > &	boundingBox = nullptr )

◆ _geometry() [2/3]

std::shared_ptr< Geometry > cil::_geometry	(	const std::shared_ptr< std::map< std::string, std::shared_ptr< Vertices > > > &	verticesSet = _verticesSet(),
		const std::shared_ptr< Indices > &	indices = nullptr,
		const std::shared_ptr< BoundingBox > &	boundingBox = nullptr )

◆ _geometry() [3/3]

std::shared_ptr< Geometry > cil::_geometry	(	std::map< std::string, std::shared_ptr< Vertices > >	verticesSet,
		const std::shared_ptr< Indices > &	indices = nullptr,
		const std::shared_ptr< BoundingBox > &	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]

std::shared_ptr< Int16Array > cil::_i16array ( const std::initializer_list< short > & array )

◆ _i16array() [2/2]

std::shared_ptr< Int16Array > cil::_i16array	(	int	size = 0,
		short *	data = nullptr,
		bool	copy = true )

◆ _i32array() [1/2]

std::shared_ptr< Int32Array > cil::_i32array ( const std::initializer_list< int > & array )

◆ _i32array() [2/2]

std::shared_ptr< Int32Array > cil::_i32array	(	int	size = 0,
		int *	data = nullptr,
		bool	copy = true )

◆ _i8array() [1/2]

std::shared_ptr< Int8Array > cil::_i8array ( const std::initializer_list< char > & array )

◆ _i8array() [2/2]

std::shared_ptr< Int8Array > cil::_i8array	(	int	size = 0,
		char *	data = nullptr,
		bool	copy = true )

◆ _image2d()

std::shared_ptr< Image2D > 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()

std::shared_ptr< ImageCube > 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]

std::shared_ptr< Integer > cil::_integer ( )

◆ _integer() [2/3]

std::shared_ptr< Integer > cil::_integer ( const Integer & other )

◆ _integer() [3/3]

std::shared_ptr< Integer > cil::_integer ( int v )

◆ _intenseSharpen()

std::shared_ptr< Pass > cil::_intenseSharpen ( const std::shared_ptr< Pass > & input )

◆ _ivec2() [1/5]

std::shared_ptr< Vector2i > cil::_ivec2 ( )

◆ _ivec2() [2/5]

std::shared_ptr< Vector2i > cil::_ivec2 ( const Vector2i & other )

◆ _ivec2() [3/5]

std::shared_ptr< Vector2i > cil::_ivec2 ( const Vector3i & other )

◆ _ivec2() [4/5]

std::shared_ptr< Vector2i > cil::_ivec2 ( const Vector4i & other )

◆ _ivec2() [5/5]

std::shared_ptr< Vector2i > cil::_ivec2	(	int	x,
		int	y )

◆ _ivec3() [1/5]

std::shared_ptr< Vector3i > cil::_ivec3 ( )

◆ _ivec3() [2/5]

std::shared_ptr< Vector3i > cil::_ivec3	(	const Vector2i &	other,
		int	z = 0 )

◆ _ivec3() [3/5]

std::shared_ptr< Vector3i > cil::_ivec3 ( const Vector3i & other )

◆ _ivec3() [4/5]

std::shared_ptr< Vector3i > cil::_ivec3 ( const Vector4i & other )

◆ _ivec3() [5/5]

std::shared_ptr< Vector3i > cil::_ivec3	(	int	x,
		int	y,
		int	z )

◆ _ivec4() [1/5]

std::shared_ptr< Vector4i > cil::_ivec4 ( )

◆ _ivec4() [2/5]

std::shared_ptr< Vector4i > cil::_ivec4	(	const Vector2i &	other,
		int	z = 0,
		int	w = 0 )

◆ _ivec4() [3/5]

std::shared_ptr< Vector4i > cil::_ivec4	(	const Vector3i &	other,
		int	w = 0 )

◆ _ivec4() [4/5]

std::shared_ptr< Vector4i > cil::_ivec4 ( const Vector4i & other )

◆ _ivec4() [5/5]

std::shared_ptr< Vector4i > 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()

std::shared_ptr< Line > cil::_line ( float width = 1.0f )

◆ _line_loop() [1/5]

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

◆ _line_loop() [2/5]

std::shared_ptr< ElementIndices > cil::_line_loop	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _line_loop() [3/5]

std::shared_ptr< ElementIndices > cil::_line_loop	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _line_loop() [4/5]

std::shared_ptr< ElementIndices > cil::_line_loop	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _line_loop() [5/5]

std::shared_ptr< ArrayIndices > cil::_line_loop	(	int	count,
		int	first = 0,
		int	primCount = 0 )

◆ _line_strip() [1/5]

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

◆ _line_strip() [2/5]

std::shared_ptr< ElementIndices > cil::_line_strip	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _line_strip() [3/5]

std::shared_ptr< ElementIndices > cil::_line_strip	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _line_strip() [4/5]

std::shared_ptr< ElementIndices > cil::_line_strip	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _line_strip() [5/5]

std::shared_ptr< ArrayIndices > 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]

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

◆ _lines() [2/5]

std::shared_ptr< ElementIndices > cil::_lines	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _lines() [3/5]

std::shared_ptr< ElementIndices > cil::_lines	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _lines() [4/5]

std::shared_ptr< ElementIndices > cil::_lines	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _lines() [5/5]

std::shared_ptr< ArrayIndices > 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]

std::shared_ptr< Matrix2f > cil::_mat2 ( )

◆ _mat2() [2/6]

std::shared_ptr< Matrix2f > cil::_mat2 ( const Matrix2f & other )

◆ _mat2() [3/6]

std::shared_ptr< Matrix2f > cil::_mat2 ( const Matrix3f & other )

◆ _mat2() [4/6]

std::shared_ptr< Matrix2f > cil::_mat2 ( const Matrix4f & other )

◆ _mat2() [5/6]

std::shared_ptr< Matrix2f > cil::_mat2	(	const Vector2f &	c0,
		const Vector2f &	c1 )

◆ _mat2() [6/6]

std::shared_ptr< Matrix2f > cil::_mat2	(	float	e00,
		float	e01,
		float	e10,
		float	e11 )

◆ _mat3() [1/6]

std::shared_ptr< Matrix3f > cil::_mat3 ( )

◆ _mat3() [2/6]

std::shared_ptr< Matrix3f > cil::_mat3 ( const Matrix2f & other )

◆ _mat3() [3/6]

std::shared_ptr< Matrix3f > cil::_mat3 ( const Matrix3f & other )

◆ _mat3() [4/6]

std::shared_ptr< Matrix3f > cil::_mat3 ( const Matrix4f & other )

◆ _mat3() [5/6]

std::shared_ptr< Matrix3f > cil::_mat3	(	const Vector3f &	c0,
		const Vector3f &	c1,
		const Vector3f &	c2 )

◆ _mat3() [6/6]

std::shared_ptr< Matrix3f > cil::_mat3	(	float	e00,
		float	e01,
		float	e02,
		float	e10,
		float	e11,
		float	e12,
		float	e20,
		float	e21,
		float	e22 )

◆ _mat4() [1/6]

std::shared_ptr< Matrix4f > cil::_mat4 ( )

◆ _mat4() [2/6]

std::shared_ptr< Matrix4f > cil::_mat4 ( const Matrix2f & other )

◆ _mat4() [3/6]

std::shared_ptr< Matrix4f > cil::_mat4 ( const Matrix3f & other )

◆ _mat4() [4/6]

std::shared_ptr< Matrix4f > cil::_mat4 ( const Matrix4f & other )

◆ _mat4() [5/6]

std::shared_ptr< Matrix4f > cil::_mat4	(	const Vector4f &	c0,
		const Vector4f &	c1,
		const Vector4f &	c2,
		const Vector4f &	c3 )

◆ _mat4() [6/6]

std::shared_ptr< Matrix4f > 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]

std::shared_ptr< Material > cil::_material ( const std::map< std::string, std::shared_ptr< Variant > > & parameters )

◆ _material() [2/13]

std::shared_ptr< Material > cil::_material	(	const std::map< std::string, std::shared_ptr< Variant > > &	parameters,
		const std::vector< std::shared_ptr< State > > &	states )

◆ _material() [3/13]

std::shared_ptr< Material > cil::_material	(	const std::shared_ptr< Program > &	program,
		const std::map< std::string, std::shared_ptr< Variant > > &	parameters )

◆ _material() [4/13]

std::shared_ptr< Material > cil::_material	(	const std::shared_ptr< Program > &	program,
		const std::map< std::string, std::shared_ptr< Variant > > &	parameters,
		const std::vector< std::shared_ptr< State > > &	states )

◆ _material() [5/13]

std::shared_ptr< Material > cil::_material	(	const std::shared_ptr< Program > &	program,
		const std::shared_ptr< std::vector< std::shared_ptr< State > > > &	states )

◆ _material() [6/13]

std::shared_ptr< Material > cil::_material	(	const std::shared_ptr< Program > &	program,
		const std::vector< std::shared_ptr< State > > &	states )

◆ _material() [7/13]

std::shared_ptr< Material > cil::_material	(	const std::shared_ptr< Program > &	program = nullptr,
		const std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > > &	parameters = nullptr,
		const std::shared_ptr< std::vector< std::shared_ptr< State > > > &	states = nullptr )

◆ _material() [8/13]

std::shared_ptr< Material > cil::_material	(	const std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > > &	parameters,
		const std::shared_ptr< std::vector< std::shared_ptr< State > > > &	states = nullptr )

◆ _material() [9/13]

std::shared_ptr< Material > cil::_material ( const std::vector< std::shared_ptr< Source > > & sources )

◆ _material() [10/13]

std::shared_ptr< Material > cil::_material	(	const std::vector< std::shared_ptr< Source > > &	sources,
		const std::map< std::string, std::shared_ptr< Variant > > &	parameters )

◆ _material() [11/13]

std::shared_ptr< Material > cil::_material	(	const std::vector< std::shared_ptr< Source > > &	sources,
		const std::map< std::string, std::shared_ptr< Variant > > &	parameters,
		const std::vector< std::shared_ptr< State > > &	states )

◆ _material() [12/13]

std::shared_ptr< Material > cil::_material	(	const std::vector< std::shared_ptr< Source > > &	sources,
		const std::vector< std::shared_ptr< State > > &	states )

◆ _material() [13/13]

std::shared_ptr< Material > cil::_material ( const std::vector< std::shared_ptr< State > > & 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]

std::shared_ptr< Mesh > cil::_mesh	(	const std::shared_ptr< std::vector< std::shared_ptr< Primitive > > > &	primitives = nullptr,
		const std::shared_ptr< BoundingBox > &	boundingBox = nullptr )

◆ _mesh() [2/2]

std::shared_ptr< Mesh > cil::_mesh	(	const std::vector< std::shared_ptr< Primitive > > &	primitives,
		const std::shared_ptr< BoundingBox > &	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]

std::shared_ptr< MinMax > cil::_minmax ( )

◆ _minmax() [2/3]

std::shared_ptr< MinMax > cil::_minmax ( const MinMax & other )

◆ _minmax() [3/3]

std::shared_ptr< MinMax > 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]

std::shared_ptr< Node > cil::_node	(	const std::shared_ptr< Mesh > &	mesh = nullptr,
		const std::shared_ptr< std::vector< std::shared_ptr< Node > > > &	children = nullptr,
		const std::shared_ptr< Matrix4f > &	transform = nullptr,
		const std::shared_ptr< BoundingBox > &	boundingBox = nullptr,
		const std::string &	name = "Node",
		const std::shared_ptr< Material > &	material = nullptr,
		const std::shared_ptr< Geometry > &	geometry = nullptr,
		const std::shared_ptr< Query > &	query = nullptr )

◆ _node() [2/5]

std::shared_ptr< Node > cil::_node	(	const std::shared_ptr< std::vector< std::shared_ptr< Node > > > &	children,
		const std::shared_ptr< Matrix4f > &	transform = nullptr,
		const std::shared_ptr< BoundingBox > &	boundingBox = nullptr,
		const std::string &	name = "Node",
		const std::shared_ptr< Material > &	material = nullptr,
		const std::shared_ptr< Geometry > &	geometry = nullptr,
		const std::shared_ptr< Query > &	query = nullptr )

◆ _node() [3/5]

std::shared_ptr< Node > cil::_node	(	const std::vector< std::shared_ptr< Node > > &	nodes,
		const std::shared_ptr< Matrix4f > &	transform = nullptr )

◆ _node() [4/5]

std::shared_ptr< Node > cil::_node	(	const std::vector< std::shared_ptr< Primitive > > &	primitives,
		const std::shared_ptr< Matrix4f > &	transform = nullptr )

◆ _node() [5/5]

std::shared_ptr< Node > cil::_node	(	const std::vector< std::shared_ptr< Primitive > > &	primitives,
		const std::vector< std::shared_ptr< Node > > &	nodes,
		const std::shared_ptr< Matrix4f > &	transform = nullptr )

◆ _nodes()

std::shared_ptr< std::vector< std::shared_ptr< Node > > > cil::_nodes ( const std::vector< std::shared_ptr< Node > > & 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, std::shared_ptr< Variant > > > cil::_parameters ( const std::map< std::string, std::shared_ptr< Variant > > & parameters = {} )

◆ _pass()

std::shared_ptr< Pass > cil::_pass	(	const std::shared_ptr< Node > &	node = nullptr,
		const std::shared_ptr< Background > &	background = nullptr,
		const std::shared_ptr< Camera > &	camera = nullptr,
		const std::shared_ptr< Target > &	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]

std::shared_ptr< Plane > cil::_plane ( )

◆ _plane() [2/4]

std::shared_ptr< Plane > cil::_plane ( const Plane & other )

◆ _plane() [3/4]

std::shared_ptr< Plane > cil::_plane	(	const Vector3f &	origin,
		const Vector3f &	normal )

◆ _plane() [4/4]

std::shared_ptr< Plane > 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()

std::shared_ptr< Point > 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]

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

◆ _points() [2/5]

std::shared_ptr< ElementIndices > cil::_points	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _points() [3/5]

std::shared_ptr< ElementIndices > cil::_points	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _points() [4/5]

std::shared_ptr< ElementIndices > cil::_points	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _points() [5/5]

std::shared_ptr< ArrayIndices > cil::_points	(	int	count,
		int	first = 0,
		int	primCount = 0 )

◆ _polygon()

std::shared_ptr< Polygon > cil::_polygon ( Polygon::Mode mode = Polygon::Mode::FILL )

◆ _polygonOffset()

std::shared_ptr< PolygonOffset > 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]

std::shared_ptr< Primitive > cil::_primitive	(	const std::shared_ptr< Geometry > &	geometry = nullptr,
		const std::shared_ptr< Material > &	material = nullptr,
		int	priority = 0 )

◆ _primitive() [2/2]

std::shared_ptr< Primitive > cil::_primitive	(	const std::shared_ptr< Material > &	material,
		int	priority = 0 )

◆ _primitives()

std::shared_ptr< std::vector< std::shared_ptr< Primitive > > > cil::_primitives ( const std::vector< std::shared_ptr< Primitive > > & 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]

std::shared_ptr< Program > cil::_program	(	const std::shared_ptr< FragmentSource > &	fragment,
		const std::shared_ptr< GeometrySource > &	geometry = nullptr )

◆ _program() [2/6]

std::shared_ptr< Program > cil::_program ( const std::shared_ptr< GeometrySource > & geometry )

◆ _program() [3/6]

std::shared_ptr< Program > cil::_program	(	const std::shared_ptr< VertexSource > &	vertex = nullptr,
		const std::shared_ptr< FragmentSource > &	fragment = nullptr,
		const std::shared_ptr< GeometrySource > &	geometry = nullptr )

◆ _program() [4/6]

std::shared_ptr< Program > cil::_program ( const std::string & vertexString )

◆ _program() [5/6]

std::shared_ptr< Program > cil::_program	(	const std::string &	vertexString,
		const std::string &	fragmentString )

◆ _program() [6/6]

std::shared_ptr< Program > cil::_program	(	const std::string &	vertexString,
		const std::string &	fragmentString,
		const std::string &	geometryString )

◆ _purple()

std::shared_ptr< Color3f > cil::_purple ( )

◆ _quat() [1/4]

std::shared_ptr< Quaternion > cil::_quat ( )

◆ _quat() [2/4]

std::shared_ptr< Quaternion > cil::_quat ( const Quaternion & other )

◆ _quat() [3/4]

std::shared_ptr< Quaternion > cil::_quat	(	const Vector3f &	axis,
		float	angle )

◆ _quat() [4/4]

std::shared_ptr< Quaternion > 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]

std::shared_ptr< Ray > cil::_ray ( )

◆ _ray() [2/3]

std::shared_ptr< Ray > cil::_ray ( const Ray & other )

◆ _ray() [3/3]

std::shared_ptr< Ray > cil::_ray	(	const Vector3f &	origin,
		const Vector3f &	normal )

◆ _real() [1/3]

std::shared_ptr< Real > cil::_real ( )

◆ _real() [2/3]

std::shared_ptr< Real > cil::_real ( const Real & other )

◆ _real() [3/3]

std::shared_ptr< Real > 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()

std::shared_ptr< Sampler > 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()

std::shared_ptr< Sampler > cil::_samplerClamp ( )

◆ _samplerCube()

std::shared_ptr< Sampler > cil::_samplerCube ( )

◆ _samplerMirror()

std::shared_ptr< Sampler > cil::_samplerMirror ( )

◆ _samplerRepeat()

std::shared_ptr< Sampler > 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]

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

◆ _scene() [2/2]

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

◆ _scissor()

std::shared_ptr< Scissor > 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()

std::shared_ptr< Background > cil::_simpleBackground	(	const std::shared_ptr< Vector2i > &	size,
		const std::shared_ptr< Color4f > &	colorMask = _clr4(0.7, 0.7, 0.7, 1.0),
		const std::shared_ptr< Real > &	depthMask = _real(1.0),
		const std::shared_ptr< Integer > &	stencilMask = nullptr,
		const std::shared_ptr< Vector2i > &	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< std::shared_ptr< State > > > cil::_states ( const std::vector< std::shared_ptr< State > > & states = {} )

◆ _steelblue()

std::shared_ptr< Color3f > cil::_steelblue ( )

◆ _stencil()

std::shared_ptr< Stencil > 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]

std::shared_ptr< Target > cil::_target ( )

◆ _target() [2/2]

std::shared_ptr< Target > cil::_target ( const std::vector< std::shared_ptr< ImageBuffer > > & 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()

std::shared_ptr< Texture > cil::_texture	(	int	unit,
		const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture0()

std::shared_ptr< Texture > cil::_texture0	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture1()

std::shared_ptr< Texture > cil::_texture1	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture2()

std::shared_ptr< Texture > cil::_texture2	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture3()

std::shared_ptr< Texture > cil::_texture3	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture4()

std::shared_ptr< Texture > cil::_texture4	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture5()

std::shared_ptr< Texture > cil::_texture5	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture6()

std::shared_ptr< Texture > cil::_texture6	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	sampler = nullptr )

◆ _texture7()

std::shared_ptr< Texture > cil::_texture7	(	const std::shared_ptr< Image > &	image,
		const std::shared_ptr< Sampler > &	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]

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

◆ _triangle_fan() [2/5]

std::shared_ptr< ElementIndices > cil::_triangle_fan	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangle_fan() [3/5]

std::shared_ptr< ElementIndices > cil::_triangle_fan	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangle_fan() [4/5]

std::shared_ptr< ElementIndices > cil::_triangle_fan	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangle_fan() [5/5]

std::shared_ptr< ArrayIndices > cil::_triangle_fan	(	int	count,
		int	first = 0,
		int	primCount = 0 )

◆ _triangle_strip() [1/5]

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

◆ _triangle_strip() [2/5]

std::shared_ptr< ElementIndices > cil::_triangle_strip	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangle_strip() [3/5]

std::shared_ptr< ElementIndices > cil::_triangle_strip	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangle_strip() [4/5]

std::shared_ptr< ElementIndices > cil::_triangle_strip	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangle_strip() [5/5]

std::shared_ptr< ArrayIndices > 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]

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

◆ _triangles() [2/5]

std::shared_ptr< ElementIndices > cil::_triangles	(	const std::shared_ptr< Uint16Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangles() [3/5]

std::shared_ptr< ElementIndices > cil::_triangles	(	const std::shared_ptr< Uint32Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangles() [4/5]

std::shared_ptr< ElementIndices > cil::_triangles	(	const std::shared_ptr< Uint8Array > &	buffer,
		int	count = -1,
		int	offset = 0,
		int	primCount = 0 )

◆ _triangles() [5/5]

std::shared_ptr< ArrayIndices > cil::_triangles	(	int	count,
		int	first = 0,
		int	primCount = 0 )

◆ _turquoise()

std::shared_ptr< Color3f > cil::_turquoise ( )

◆ _u16array() [1/2]

std::shared_ptr< Uint16Array > cil::_u16array ( const std::initializer_list< unsigned short > & array )

◆ _u16array() [2/2]

std::shared_ptr< Uint16Array > cil::_u16array	(	int	size = 0,
		unsigned short *	data = nullptr,
		bool	copy = true )

◆ _u32array() [1/2]

std::shared_ptr< Uint32Array > cil::_u32array ( const std::initializer_list< unsigned int > & array )

◆ _u32array() [2/2]

std::shared_ptr< Uint32Array > cil::_u32array	(	int	size = 0,
		unsigned int *	data = nullptr,
		bool	copy = true )

◆ _u8array() [1/2]

std::shared_ptr< Uint8Array > cil::_u8array ( const std::initializer_list< unsigned char > & array )

◆ _u8array() [2/2]

std::shared_ptr< Uint8Array > cil::_u8array	(	int	size = 0,
		unsigned char *	data = nullptr,
		bool	copy = true )

◆ _vec2() [1/5]

std::shared_ptr< Vector2f > cil::_vec2 ( )

◆ _vec2() [2/5]

std::shared_ptr< Vector2f > cil::_vec2 ( const Vector2f & other )

◆ _vec2() [3/5]

std::shared_ptr< Vector2f > cil::_vec2 ( const Vector3f & other )

◆ _vec2() [4/5]

std::shared_ptr< Vector2f > cil::_vec2 ( const Vector4f & other )

◆ _vec2() [5/5]

std::shared_ptr< Vector2f > cil::_vec2	(	float	x,
		float	y )

◆ _vec3() [1/5]

std::shared_ptr< Vector3f > cil::_vec3 ( )

◆ _vec3() [2/5]

std::shared_ptr< Vector3f > cil::_vec3	(	const Vector2f &	other,
		float	z = 0 )

◆ _vec3() [3/5]

std::shared_ptr< Vector3f > cil::_vec3 ( const Vector3f & other )

◆ _vec3() [4/5]

std::shared_ptr< Vector3f > cil::_vec3 ( const Vector4f & other )

◆ _vec3() [5/5]

std::shared_ptr< Vector3f > cil::_vec3	(	float	x,
		float	y,
		float	z )

◆ _vec4() [1/5]

std::shared_ptr< Vector4f > cil::_vec4 ( )

◆ _vec4() [2/5]

std::shared_ptr< Vector4f > cil::_vec4	(	const Vector2f &	other,
		float	z = 0,
		float	w = 0 )

◆ _vec4() [3/5]

std::shared_ptr< Vector4f > cil::_vec4	(	const Vector3f &	other,
		float	w = 0 )

◆ _vec4() [4/5]

std::shared_ptr< Vector4f > cil::_vec4 ( const Vector4f & other )

◆ _vec4() [5/5]

std::shared_ptr< Vector4f > cil::_vec4	(	float	x,
		float	y,
		float	z,
		float	w )

◆ _vert()

std::shared_ptr< VertexSource > 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]

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

◆ _vertices() [2/3]

std::shared_ptr< Vertices > cil::_vertices	(	const std::shared_ptr< Float32Array > &	buffer,
		int	offset = 0,
		unsigned int	stride = 0,
		unsigned int	divisor = 0 )

◆ _vertices() [3/3]

std::shared_ptr< Vertices > cil::_vertices	(	const std::shared_ptr< Int32Array > &	buffer,
		int	offset = 0,
		unsigned int	stride = 0,
		unsigned int	divisor = 0 )

◆ _verticesSet()

std::shared_ptr< std::map< std::string, std::shared_ptr< Vertices > > > cil::_verticesSet ( const std::map< std::string, std::shared_ptr< Vertices > > & 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 )

◆ 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()

VizPartPtrArray cil::extractDataModel	(	const DataModelPtr &	dataModel,
		const ParametersPtr &	parameters )

◆ extractDataModelById()

VizPartPtrArray cil::extractDataModelById	(	const DataSolutionPtr &	dataSolution,
		int	id,
		const ParametersPtr &	parameters )

◆ extractDataPart()

VizPartPtr cil::extractDataPart	(	const DataPartPtr &	dataPart,
		const ParametersPtr &	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 )

◆ generatePartArrayPrimitive()

std::vector< std::shared_ptr< Primitive > > cil::generatePartArrayPrimitive	(	const VizPartPtrArray &	vizParts,
		const AttributesPtr &	attributes,
		const std::shared_ptr< ScenarioSettings > &	settings )

◆ 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]

std::shared_ptr< BoundingBox > cil::getBoundingBox	(	const std::shared_ptr< Geometry > &	geometry,
		const std::string &	attribName = "positions" )

◆ getBoundingBox() [2/6]

std::shared_ptr< BoundingBox > cil::getBoundingBox ( const std::shared_ptr< Mesh > & mesh )

◆ getBoundingBox() [3/6]

std::shared_ptr< BoundingBox > cil::getBoundingBox ( const std::shared_ptr< Node > & node )

◆ getBoundingBox() [4/6]

std::shared_ptr< BoundingBox > cil::getBoundingBox ( const std::shared_ptr< Pass > & pass )

◆ getBoundingBox() [5/6]

std::shared_ptr< BoundingBox > cil::getBoundingBox ( const std::shared_ptr< Primitive > & primitive )

◆ getBoundingBox() [6/6]

std::shared_ptr< BoundingBox > cil::getBoundingBox ( const std::shared_ptr< Scene > & 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 )

◆ openSolution()

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

◆ 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 )

◆ 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 )

◆ 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 )

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ AttributesPtr

◆ bbox

◆ BlockAttributesPtr

◆ BlockPtr

◆ box2

◆ box3

◆ ClipParametersPtr

◆ ClipPtr

◆ clr3

◆ clr3ub

◆ clr4

◆ clr4ub

◆ ContourParametersPtr

◆ ContourPtr

◆ CrinkleClipParametersPtr

◆ CrinkleClipPtr

◆ CrinkleSliceParametersPtr

◆ CrinkleSlicePtr

◆ CrinkleSolidParametersPtr

◆ CrinkleSolidPtr

◆ DataModelPtr

◆ DataModelPtrArray

◆ DataPartPtr

◆ DataPartPtrArray

◆ DataScalar

◆ DataSolutionPtr

◆ DataVector

◆ f32array

◆ f64array

◆ FilterFunction

◆ FilterPtr

◆ FilterPtrArray

◆ frag

◆ FringeSurfaceParametersPtr

◆ FringeSurfacePtr

◆ geom

◆ i16array

◆ i32array

◆ i8array

◆ ibox2

◆ ibox3

◆ image2d

◆ imageBuf

◆ imageCube

◆ integer

◆ IsoVolumeParametersPtr

◆ IsoVolumePtr

◆ ivec2

◆ ivec3

◆ ivec4

◆ mat2

◆ mat3

◆ mat4

◆ minmax

◆ ParametersPtr

◆ PartAttributesPtr

◆ plane

◆ PointAttributesPtr

◆ PointCloudParametersPtr

◆ PointCloudPtr

◆ PointParametersPtr

◆ PolygonAttributesPtr

◆ PolygonSurfaceParametersPtr

◆ PolygonSurfacePtr

◆ ProbePtr

◆ quat

◆ ray

◆ real

◆ RibbonParametersPtr

◆ RibbonPtr

◆ SliceParametersPtr

◆ SlicePtr

◆ SolidParametersPtr

◆ SolidPtr

◆ StreamSurfaceParametersPtr