Cinder  0.9.1
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
cinder Namespace Reference

Namespaces

 app
 
 audio
 
 cairo
 
 cocoa
 
 detail
 
 dx
 
 geom
 
 gl
 
 ip
 
 log
 
 msw
 
 params
 
 qtime
 
 signals
 
 svg
 
 winrt
 

Classes

class  Anim
 
class  AnimBase
 
class  Arcball
 
class  Area
 
class  AxisAlignedBox
 
class  BandedMatrix
 
class  BSpline
 
class  BSplineBasis
 
class  Buffer
 
class  CallbackMgr
 
class  Camera
 
class  CameraOrtho
 
class  CameraPersp
 
class  CameraStereo
 
class  CameraUi
 
class  Capture
 
class  CaptureExc
 
class  CaptureExcInitFail
 
class  CaptureExcInvalidChannelOrder
 
class  CaptureImplAvFoundationDevice
 
class  CaptureImplCocoaDummyDevice
 
class  CaptureImplDirectShow
 
class  ChannelT
 
struct  CHANTRAIT
 
struct  CHANTRAIT< float >
 
struct  CHANTRAIT< half_float >
 
struct  CHANTRAIT< uint16_t >
 
struct  CHANTRAIT< uint8_t >
 
class  Clipboard
 
class  ColorAT
 
struct  COLORDIM
 
struct  COLORDIM< 3, float >
 
struct  COLORDIM< 3, uint8_t >
 
struct  COLORDIM< 4, float >
 
struct  COLORDIM< 4, uint8_t >
 
class  ColorT
 
struct  CompareNode
 
class  ConcurrentCircularBuffer
 
class  Cue
 
class  DataSource
 
class  DataSourceBuffer
 
class  DataSourcePath
 
class  DataSourceUrl
 
class  DataTarget
 
class  DataTargetPath
 
class  DataTargetStream
 
class  Display
 
class  DisplayCocoaTouch
 
class  DisplayMsw
 
class  DisplayWinRt
 
struct  EaseInAtan
 
struct  EaseInBack
 
struct  EaseInBounce
 
struct  EaseInCirc
 
struct  EaseInCubic
 
struct  EaseInElastic
 
struct  EaseInExpo
 
struct  EaseInOutAtan
 
struct  EaseInOutBack
 
struct  EaseInOutBounce
 
struct  EaseInOutCirc
 
struct  EaseInOutCubic
 
struct  EaseInOutElastic
 
struct  EaseInOutExpo
 
struct  EaseInOutQuad
 
struct  EaseInOutQuart
 
struct  EaseInOutQuint
 
struct  EaseInOutSine
 
struct  EaseInQuad
 
struct  EaseInQuart
 
struct  EaseInQuint
 
struct  EaseInSine
 
struct  EaseNone
 
struct  EaseOutAtan
 
struct  EaseOutBack
 
struct  EaseOutBounce
 
struct  EaseOutCirc
 
struct  EaseOutCubic
 
struct  EaseOutElastic
 
struct  EaseOutExpo
 
struct  EaseOutInBack
 
struct  EaseOutInBounce
 
struct  EaseOutInCirc
 
struct  EaseOutInCubic
 
struct  EaseOutInElastic
 
struct  EaseOutInExpo
 
struct  EaseOutInQuad
 
struct  EaseOutInQuart
 
struct  EaseOutInQuint
 
struct  EaseOutInSine
 
struct  EaseOutQuad
 
struct  EaseOutQuart
 
struct  EaseOutQuint
 
struct  EaseOutSine
 
class  Exception
 
class  FilterBase
 
class  FilterBesselBlackman
 
class  FilterBox
 
class  FilterCatmullRom
 
class  FilterCubic
 
class  FilterGaussian
 
class  FilterMitchell
 
class  FilterQuadratic
 
class  FilterSincBlackman
 
class  FilterTriangle
 
class  FnTween
 
class  FnTweenRef
 
class  Font
 
class  FontGlyphFailureExc
 
class  FontInvalidNameExc
 
class  FrustumT
 
union  half_float
 
class  ImageIo
 
class  ImageIoException
 
class  ImageIoExceptionFailedLoad
 
class  ImageIoExceptionFailedLoadTinyExr
 
class  ImageIoExceptionFailedWrite
 
class  ImageIoExceptionFailedWriteTinyExr
 
class  ImageIoExceptionIllegalChannelOrder
 
class  ImageIoExceptionIllegalColorModel
 
class  ImageIoExceptionIllegalDataType
 
class  ImageIoExceptionUnknownExtension
 
struct  ImageIoRegistrar
 
class  ImageSource
 
class  ImageSourceFileQuartz
 
class  ImageSourceFileQuartzExceptionUnsupportedData
 
class  ImageSourceFileRadiance
 
class  ImageSourceFileRadianceException
 
class  ImageSourceFileStbImage
 
class  ImageSourceFileTinyExr
 
class  ImageSourceFileWic
 
class  ImageSourceFileWicExceptionUnsupportedData
 
class  ImageSourcePng
 
class  ImageSourcePngException
 
class  ImageTarget
 
class  ImageTargetFileQuartz
 
class  ImageTargetFileStbImage
 
class  ImageTargetFileTinyExr
 
class  ImageTargetFileWic
 
class  IoStream
 
class  IoStreamFile
 
class  IStreamCinder
 
class  IStreamFile
 
class  IStreamMem
 
class  IStreamStateRestore
 
class  IStreamUrl
 
class  IStreamUrlImplCocoa
 
class  IStreamUrlImplCurl
 
class  IStreamUrlImplWinInet
 
class  JsonTree
 
struct  KdNode
 
class  KdTree
 
struct  math
 
struct  math< float >
 
struct  NodeDataTraits
 
struct  NodeDataTraits< vec2 >
 
struct  NodeDataVectorTraits
 
struct  Noncopyable
 
struct  NullLookupProc
 
class  ObjLoader
 
class  OStream
 
class  OStreamFile
 
class  OStreamMem
 
class  ParallelTransport
 
class  Path2d
 
class  Path2dCalcCache
 
class  Path2dExc
 
class  Perlin
 
class  PlaneExc
 
class  PlaneT
 
class  PolyLineT
 
class  Rand
 
class  Ray
 
class  RectMapping
 
class  RectT
 
class  Serial
 
class  SerialExc
 
class  SerialExcDeviceEnumerationFailed
 
class  SerialExcOpenFailed
 
class  SerialExcReadFailure
 
class  SerialExcWriteFailure
 
class  SerialTimeoutExc
 
class  Shape2d
 
class  Sphere
 
class  StreamBase
 
class  StreamExc
 
class  StreamExcOutOfMemory
 
class  SurfaceChannelOrder
 
class  SurfaceConstraints
 
class  SurfaceConstraintsCairo
 
class  SurfaceConstraintsDefault
 
class  SurfaceConstraintsExc
 
class  SurfaceConstraintsGdiPlus
 
class  SurfaceExc
 
class  SurfaceT
 
class  SvgRendererGl
 
class  System
 
class  SystemExc
 
class  SystemExcFailedQuery
 
class  TextBox
 
class  TextLayout
 
class  ThreadSetup
 
class  Timeline
 
class  TimelineItem
 
class  Timer
 
class  Triangulator
 
class  TriMesh
 
class  Tween
 
class  TweenBase
 
class  TweenRef
 
class  Url
 
class  UrlLoadExc
 
class  UrlOptions
 
struct  VECDIM
 
struct  VECDIM< 2, double >
 
struct  VECDIM< 2, float >
 
struct  VECDIM< 2, int >
 
struct  VECDIM< 3, double >
 
struct  VECDIM< 3, float >
 
struct  VECDIM< 3, int >
 
struct  VECDIM< 4, double >
 
struct  VECDIM< 4, float >
 
struct  VECDIM< 4, int >
 
class  XmlTree
 

Typedefs

typedef std::shared_ptr< DisplayDisplayRef
 
typedef BandedMatrix< float > BandedMatrixf
 
typedef BandedMatrix< double > BandedMatrixd
 
typedef BSpline< 2, float > BSpline2f
 
typedef BSpline< 3, float > BSpline3f
 
typedef std::shared_ptr< class BufferBufferRef
 
typedef std::shared_ptr< class DataSourceDataSourceRef
 
typedef std::shared_ptr< class DataTargetDataTargetRef
 
typedef std::shared_ptr< class CaptureCaptureRef
 
typedef std::shared_ptr< class ImageSourceImageSourceRef
 
typedef ChannelT< uint8_t > Channel
 
typedef ChannelT< uint8_t > Channel8u
 
typedef std::shared_ptr< Channel8uChannel8uRef
 
typedef std::shared_ptr< Channel8uChannelRef
 
typedef ChannelT< uint16_t > Channel16u
 
typedef std::shared_ptr< Channel16uChannel16uRef
 
typedef ChannelT< float > Channel32f
 
typedef std::shared_ptr< Channel32fChannel32fRef
 
typedef ColorT< float > Colorf
 
typedef Colorf Color
 
typedef ColorT< uint8_t > Color8u
 
typedef ColorAT< float > ColorA
 
typedef ColorAT< float > ColorAf
 
typedef ColorAT< uint8_t > ColorA8u
 
typedef std::shared_ptr< class DataSourcePathDataSourcePathRef
 
typedef std::shared_ptr< class DataSourceUrlDataSourceUrlRef
 
typedef std::shared_ptr< class DataSourceBufferDataSourceBufferRef
 
typedef std::shared_ptr< class DataTargetPathDataTargetPathRef
 
typedef std::shared_ptr< class DataTargetStreamDataTargetStreamRef
 
typedef FrustumT< float > Frustum
 
typedef FrustumT< float > Frustumf
 
typedef FrustumT< double > Frustumd
 
typedef uint32_t CallbackId
 
typedef std::shared_ptr< class ImageTargetFileTinyExrImageTargetFileTinyExrRef
 
typedef std::shared_ptr< class ImageSourceFileTinyExrImageSourceFileTinyExrRef
 
typedef std::shared_ptr< class ImageLoader > ImageLoaderRef
 
typedef std::shared_ptr< class ImageTargetImageTargetRef
 
typedef std::shared_ptr< class ImageTargetFile > ImageTargetFileRef
 
typedef std::shared_ptr< class ImageSourceFileQuartzImageSourceFileQuartzRef
 
typedef std::shared_ptr< IStreamCinderIStreamRef
 
typedef std::shared_ptr< class ImageSourceFileRadianceImageSourceFileRadianceRef
 
typedef std::shared_ptr< class ImageSourceFileStbImageImageSourceFileStbImageRef
 
typedef std::shared_ptr< class ImageSourceFileWicImageSourceFileWicRef
 
typedef std::shared_ptr< class ImageSourcePngImageSourcePngRef
 
typedef std::shared_ptr< class ImageTargetFileQuartzImageTargetFileQuartzRef
 
typedef std::shared_ptr< class ImageTargetFileStbImageImageTargetFileStbImageRef
 
typedef std::shared_ptr< class ImageTargetFileWicImageTargetFileWicRef
 
typedef PlaneT< float > Plane
 
typedef PlaneT< float > Planef
 
typedef PlaneT< double > Planed
 
typedef PolyLineT< vec2 > PolyLine2
 
typedef PolyLineT< vec2 > PolyLine2f
 
typedef PolyLineT< dvec2 > PolyLine2d
 
typedef PolyLineT< vec3 > PolyLine3
 
typedef PolyLineT< vec3 > PolyLine3f
 
typedef PolyLineT< dvec3 > PolyLine3d
 
typedef RectT< float > Rectf
 
typedef RectT< double > Rectd
 
typedef std::shared_ptr< class SerialSerialRef
 
typedef std::shared_ptr< class OStreamOStreamRef
 
typedef std::shared_ptr< IoStreamIoStreamRef
 
typedef std::shared_ptr< class IStreamFileIStreamFileRef
 
typedef std::shared_ptr< class OStreamFileOStreamFileRef
 
typedef std::shared_ptr< class IoStreamFileIoStreamFileRef
 
typedef std::shared_ptr< class IStreamMemIStreamMemRef
 
typedef std::shared_ptr< class OStreamMemOStreamMemRef
 
typedef SurfaceT< uint8_t > Surface
 
typedef SurfaceT< uint8_t > Surface8u
 
typedef std::shared_ptr< Surface8uSurface8uRef
 
typedef std::shared_ptr< Surface8uSurfaceRef
 
typedef SurfaceT< uint16_t > Surface16u
 
typedef std::shared_ptr< Surface16uSurface16uRef
 
typedef SurfaceT< float > Surface32f
 
typedef std::shared_ptr< Surface32fSurface32fRef
 
typedef std::shared_ptr< class CueCueRef
 
typedef std::shared_ptr< class TimelineTimelineRef
 
typedef std::shared_ptr< class TimelineItemTimelineItemRef
 
typedef std::shared_ptr< class TriMeshTriMeshRef
 
typedef std::function< float(float)> EaseFn
 
typedef std::shared_ptr< class IStreamUrlIStreamUrlRef
 
typedef BSplineFit< float > BSplineFitf
 
typedef BSplineFit< double > BSplineFitd
 
typedef BSplineFitBasis< float > BSplineFitBasisf
 
typedef BSplineFitBasis< double > BSplineFitBasisd
 
typedef boost::geometry::model::polygon< boost::geometry::model::d2::point_xy< double > > polygon
 
typedef struct cinder::_LOGICALPROCESSORDATA LOGICALPROCESSORDATA
 
typedef struct cinder::_LOGICALPROCESSORDATA * PLOGICALPROCESSORDATA
 
typedef std::multimap< void *, TimelineItemRef >::iterator s_iter
 
typedef std::multimap< void *, TimelineItemRef >::const_iterator s_const_iter
 

Enumerations

enum  ColorModel { CM_RGB, CM_HSV }
 
enum  UnicodeBreaks { UNICODE_MUST_BREAK, UNICODE_ALLOW_BREAK, UNICODE_NO_BREAK, UNICODE_INSIDE_CHAR }
 

Functions

std::pair< Area, ivec2 > clippedSrcDst (const Area &srcSurfaceBounds, const Area &srcArea, const Area &dstSurfaceBounds, const ivec2 &dstLT)
 
std::string toBase64 (const std::string &input, int charsPerLine=0)
 
std::string toBase64 (const Buffer &input, int charsPerLine=0)
 
std::string toBase64 (const void *input, size_t inputSize, int charsPerLine=0)
 
Buffer fromBase64 (const std::string &input)
 
Buffer fromBase64 (const Buffer &input)
 
Buffer fromBase64 (const void *input, size_t inputSize)
 
template<int D, typename T >
BSpline< D, T > fitBSpline (const std::vector< typename BSpline< D, T >::VecT > &samples, int degree, int outputSamples)
 
Buffer compressBuffer (const Buffer &buffer, int8_t compressionLevel=DEFAULT_COMPRESSION_LEVEL, bool resizeResult=true)
 
Buffer decompressBuffer (const Buffer &buffer, bool resizeResult=true, bool useGZip=false)
 
float toRadians (float x)
 
double toRadians (double x)
 
float toDegrees (float x)
 
double toDegrees (double x)
 
template<typename T , typename L >
lerp (const T &a, const T &b, L factor)
 
template<typename T >
lmap (T val, T inMin, T inMax, T outMin, T outMax)
 
template<typename T , typename L >
bezierInterp (T a, T b, T c, T d, L t)
 
template<typename T , typename L >
bezierInterpRef (const T &a, const T &b, const T &c, const T &d, L t)
 
template<typename T >
constrain (T val, T minVal, T maxVal)
 
template<typename T >
fract (T x)
 
template<class T >
sinx_over_x (T x)
 
uint32_t log2floor (uint32_t x)
 
uint32_t log2ceil (uint32_t x)
 
uint32_t nextPowerOf2 (uint32_t x)
 
bool isPowerOf2 (size_t x)
 
template<typename T >
int solveLinear (T a, T b, T result[1])
 
template<typename T >
int solveQuadratic (T a, T b, T c, T result[2])
 
template<typename T , int ORDER>
rombergIntegral (T a, T b, const std::function< T(T)> &SPEEDFN)
 
template<typename T >
int solveCubic (T a, T b, T c, T d, T result[3])
 
glm::vec2 getClosestPointEllipse (const glm::vec2 &center, const glm::vec2 &axisA, const glm::vec2 &axisB, const glm::vec2 &testPoint)
 
half_float floatToHalf (float f)
 
float halfToFloat (half_float h)
 
template<typename T , typename Y >
ColorT< T > operator* (Y s, const ColorT< T > &c)
 
template<typename T , typename Y >
ColorAT< T > operator* (Y s, const ColorAT< T > &c)
 
ColorT< float > hsvToRgb (const vec3 &hsv)
 
vec3 rgbToHsv (const ColorT< float > &c)
 
ColorT< uint8_t > svgNameToRgb (const char *svgName, bool *found=NULL)
 
template<typename T >
float distance (const ColorT< T > &c0, const ColorT< T > &c1)
 
template<typename T >
float distance (const ColorAT< T > &c0, const ColorAT< T > &c1)
 
template<typename T >
CHANTRAIT< T >::Accum distance2 (const ColorT< T > &c0, const ColorT< T > &c1)
 
template<typename T >
CHANTRAIT< T >::Accum distance2 (const ColorAT< T > &c0, const ColorAT< T > &c1)
 
template<typename T >
float length (const ColorT< T > &c)
 
template<typename T >
float length (const ColorAT< T > &c)
 
template<typename T >
CHANTRAIT< T >::Accum length2 (const ColorT< T > &c)
 
template<typename T >
CHANTRAIT< T >::Accum length2 (const ColorAT< T > &c)
 
template<typename T >
CHANTRAIT< T >::Accum dot (const ColorT< T > &c0, const ColorT< T > &c1)
 
template<typename T >
CHANTRAIT< T >::Accum dot (const ColorAT< T > &c0, const ColorAT< T > &c1)
 
template<typename T >
ColorT< T > normalize (const ColorT< T > &c0)
 
template<typename T >
ColorAT< T > normalize (const ColorAT< T > &c0)
 
std::ostream & operator<< (std::ostream &lhs, const ColorT< float > &rhs)
 
std::ostream & operator<< (std::ostream &lhs, const ColorAT< float > &rhs)
 
std::ostream & operator<< (std::ostream &lhs, const ColorT< uint8_t > &rhs)
 
std::ostream & operator<< (std::ostream &lhs, const ColorAT< uint8_t > &rhs)
 
PolyLine2f calcConvexHull (const std::vector< vec2 > &points)
 
PolyLine2f calcConvexHull (const vec2 *points, size_t numPoints)
 
PolyLine2f calcConvexHull (const Shape2d &shape)
 
PolyLine2f calcConvexHull (const Path2d &path)
 
PolyLine2f calcConvexHull (const PolyLine2f &polyLine)
 
DataSourceRef loadFile (const fs::path &path)
 
DataSourceRef loadUrl (const Url &Url, const UrlOptions &options=UrlOptions())
 
DataSourceRef loadUrl (const std::string &urlString, const UrlOptions &options=UrlOptions())
 
DataTargetPathRef writeFile (const fs::path &path, bool createParents=true)
 
float easeNone (float t)
 
float easeInQuad (float t)
 
float easeOutQuad (float t)
 
float easeInOutQuad (float t)
 
float easeOutInQuad (float t)
 
float easeInCubic (float t)
 
float easeOutCubic (float t)
 
float easeInOutCubic (float t)
 
float easeOutInCubic (float t)
 
float easeInQuart (float t)
 
float easeOutQuart (float t)
 
float easeInOutQuart (float t)
 
float easeOutInQuart (float t)
 
float easeInQuint (float t)
 
float easeOutQuint (float t)
 
float easeInOutQuint (float t)
 
float easeOutInQuint (float t)
 
float easeInSine (float t)
 
float easeOutSine (float t)
 
float easeInOutSine (float t)
 
float easeOutInSine (float t)
 
float easeInExpo (float t)
 
float easeOutExpo (float t)
 
float easeInOutExpo (float t)
 
float easeOutInExpo (float t)
 
float easeInCirc (float t)
 
float easeOutCirc (float t)
 
float easeInOutCirc (float t)
 
float easeOutInCirc (float t)
 
float easeInBounce (float t, float a=1.70158f)
 
float easeOutBounce (float t, float a=1.70158f)
 
float easeInOutBounce (float t, float a=1.70158f)
 
float easeOutInBounce (float t, float a=1.70158f)
 
float easeInBack (float t, float s=1.70158f)
 
float easeOutBack (float t, float s=1.70158f)
 
float easeInOutBack (float t, float s=1.70158f)
 
float easeOutInBack (float t, float s)
 
float easeInElastic (float t, float amplitude, float period)
 
float easeOutElastic (float t, float amplitude, float period)
 
float easeInOutElastic (float t, float amplitude, float period)
 
float easeOutInElastic (float t, float amplitude, float period)
 
float easeInAtan (float t, float a=15)
 
float easeOutAtan (float t, float a=15)
 
float easeInOutAtan (float t, float a=15)
 
ImageSourceRef loadImage (const fs::path &path, ImageSource::Options options=ImageSource::Options(), std::string extension="")
 
ImageSourceRef loadImage (DataSourceRef dataSource, ImageSource::Options options=ImageSource::Options(), std::string extension="")
 
void writeImage (DataTargetRef dataTarget, const ImageSourceRef &imageSource, ImageTarget::Options options=ImageTarget::Options(), std::string extension="")
 
void writeImage (const fs::path &path, const ImageSourceRef &imageSource, ImageTarget::Options options=ImageTarget::Options(), std::string extension="")
 
void writeImage (ImageTargetRef imageTarget, const ImageSourceRef &imageSource)
 
std::ostream & operator<< (std::ostream &out, const JsonTree &json)
 
glm::mat4 transform2dTo3d (const glm::mat3 &m)
 
glm::mat4 alignZAxisWithTarget (vec3 targetDir, vec3 upDir)
 
template<typename T >
glm::tmat4x4< T, glm::defaultpfirstFrame (const glm::tvec3< T, glm::defaultp > &firstPoint, const glm::tvec3< T, glm::defaultp > &secondPoint, const glm::tvec3< T, glm::defaultp > &thirdPoint)
 
template<typename T >
glm::tmat4x4< T, glm::defaultpnextFrame (const glm::tmat4x4< T, glm::defaultp > &prevMatrix, const glm::tvec3< T, glm::defaultp > &prevPoint, const glm::tvec3< T, glm::defaultp > &curPoint, glm::tvec3< T, glm::defaultp > prevTangent, glm::tvec3< T, glm::defaultp > curTangent)
 
template<typename T >
glm::tmat4x4< T, glm::defaultplastFrame (const glm::tmat4x4< T, glm::defaultp > &prevMatrix, const glm::tvec3< T, glm::defaultp > &prevPoint, const glm::tvec3< T, glm::defaultp > &lastPoint)
 
void writeObj (const DataTargetRef &dataTarget, const geom::Source &source, bool includeNormals=true, bool includeTexCoords=true)
 
void writeObj (const DataTargetRef &dataTarget, const geom::SourceRef &source, bool includeNormals=true, bool includeTexCoords=true)
 
std::ostream & operator<< (std::ostream &out, const Path2d &p)
 
template<typename T >
std::ostream & operator<< (std::ostream &o, const PlaneT< T > &p)
 
void randSeed (uint32_t seedValue)
 
bool randBool ()
 
int32_t randInt ()
 
int32_t randInt (int32_t v)
 
int32_t randInt (int32_t a, int32_t b)
 
float randFloat ()
 
float randFloat (float v)
 
float randFloat (float a, float b)
 
float randPosNegFloat (float a, float b)
 
vec3 randVec3 ()
 
vec2 randVec2 ()
 
float randGaussian ()
 
void getClippedScaledRects (const Area &srcSurfaceBounds, const Rectf &srcRect, const Area &dstSurfaceBounds, const Area &dstArea, Rectf *resultSrcRect, Area *resultDstRect)
 
IStreamFileRef loadFileStream (const fs::path &path)
 
OStreamFileRef writeFileStream (const fs::path &path, bool createParents=true)
 
IoStreamFileRef readWriteFileStream (const fs::path &path)
 
void loadStreamMemory (IStreamRef is, std::shared_ptr< uint8_t > *resultData, size_t *resultDataSize)
 
BufferRef loadStreamBuffer (IStreamRef is)
 
std::ostream & operator<< (std::ostream &outp, const System::NetworkAdapter &adapter)
 
Surface renderString (const std::string &str, const Font &font, const ColorA &color, float *baselineOffset=0)
 
template<typename T >
tweenLerp (const T &start, const T &end, float time)
 
template<>
quat tweenLerp (const quat &start, const quat &end, float time)
 
template<>
dquat tweenLerp (const dquat &start, const dquat &end, float time)
 
std::u16string toUtf16 (const char *utf8Str, size_t lengthInBytes=0)
 
std::u16string toUtf16 (const std::string &utf8Str)
 
std::u32string toUtf32 (const char *utf8Str, size_t lengthInBytes=0)
 
std::u32string toUtf32 (const std::string &utf8Str)
 
std::string toUtf8 (const char16_t *utf16Str, size_t lengthInBytes=0)
 
std::string toUtf8 (const std::u16string &utf16Str)
 
std::string toUtf8 (const char32_t *utf32str, size_t lengthInBytes=0)
 
std::string toUtf8 (const std::u32string &utf32Str)
 
std::u16string toUtf16 (const std::u32string &utf32str)
 
std::u32string toUtf32 (const std::u16string &utf16str)
 
size_t stringLengthUtf8 (const char *str, size_t lengthInBytes=0)
 
uint32_t nextCharUtf8 (const char *str, size_t *inOutByte, size_t lengthInBytes=0)
 
size_t advanceCharUtf8 (const char *str, size_t numChars, size_t lengthInBytes=0)
 
void lineBreakUtf8 (const char *str, const std::function< bool(const char *, size_t)> &measureFn, const std::function< void(const char *, size_t)> &lineProcessFn)
 
void calcLinebreaksUtf8 (const char *str, std::vector< uint8_t > *resultBreaks)
 
void calcLinebreaksUtf8 (const char *str, size_t strLength, std::vector< uint8_t > *resultBreaks)
 
void calcLinebreaksUtf16 (const uint16_t *str, std::vector< uint8_t > *resultBreaks)
 
void calcLinebreaksUtf16 (const uint16_t *str, size_t strLength, std::vector< uint8_t > *resultBreaks)
 
std::ostream & operator<< (std::ostream &out, const Url &url)
 
std::istream & operator>> (std::istream &is, Url &url)
 
IStreamUrlRef loadUrlStream (const Url &url, const UrlOptions &options=UrlOptions())
 
IStreamUrlRef loadUrlStream (const std::string &url, const std::string &user="", const std::string &password="", const UrlOptions &options=UrlOptions())
 
fs::path expandPath (const fs::path &path)
 
fs::path getHomeDirectory ()
 
fs::path getDocumentsDirectory ()
 
void launchWebBrowser (const Url &url)
 
std::vector< std::string > split (const std::string &str, char separator, bool compress=true)
 
std::vector< std::string > split (const std::string &str, const std::string &separators, bool compress=true)
 
std::string loadString (const DataSourceRef &dataSource)
 
void sleep (float milliseconds)
 
char getPathSeparator ()
 
std::map< std::string, std::string > getEnvironmentVariables ()
 
template<typename T >
std::string toString (const T &t)
 
template<typename T >
fromString (const std::string &s)
 
template<>
Url fromString (const std::string &s)
 
std::vector< std::string > stackTrace ()
 
int8_t swapEndian (int8_t val)
 
uint8_t swapEndian (uint8_t val)
 
int16_t swapEndian (int16_t val)
 
uint16_t swapEndian (uint16_t val)
 
int32_t swapEndian (int32_t val)
 
uint32_t swapEndian (uint32_t val)
 
float swapEndian (float val)
 
double swapEndian (double val)
 
void swapEndianBlock (uint16_t *blockPtr, size_t blockSizeInBytes)
 
void swapEndianBlock (float *blockPtr, size_t blockSizeInBytes)
 
template<typename T , glm::precision P>
glm::tvec3< T, P > orthogonal (const glm::tvec3< T, P > &vec)
 
std::ostream & operator<< (std::ostream &out, const XmlTree &xml)
 
template<class T >
void allocate2D (int iCols, int iRows, T **&raatArray)
 
template<class T >
void deallocate2D (T **&raatArray)
 
template BSpline< 2, float > fitBSpline (const std::vector< vec2 > &samples, int degree, int outputSamples)
 
template BSpline< 3, float > fitBSpline (const std::vector< vec3 > &samples, int degree, int outputSamples)
 
template BSpline< 4, float > fitBSpline (const std::vector< vec4 > &samples, int degree, int outputSamples)
 
template int solveCubic (float a, float b, float c, float d, float result[3])
 
template int solveCubic (double a, double b, double c, double d, double result[3])
 
vec2 getClosestPointEllipse (const vec2 &center, const vec2 &axisA, const vec2 &axisB, const vec2 &testPoint)
 
bool clipboardContainsFormat (const std::set< UINT > &formats)
 
int CALLBACK EnumFontFamiliesExProc (ENUMLOGFONTEX *lpelfe, NEWTEXTMETRICEX *lpntme, int FontType, LPARAM lParam)
 
template mat4 firstFrame (const vec3 &firstPoint, const vec3 &secondPoint, const vec3 &thirdPoint)
 
template mat4 nextFrame (const mat4 &prevMatrix, const vec3 &prevPoint, const vec3 &curPoint, vec3 prevTangent, vec3 curTangent)
 
template mat4 lastFrame (const mat4 &prevMatrix, const vec3 &prevPoint, const vec3 &lastPoint)
 
template dmat4 firstFrame (const dvec3 &firstPoint, const dvec3 &secondPoint, const dvec3 &thirdPoint)
 
template dmat4 nextFrame (const dmat4 &prevMatrix, const dvec3 &prevPoint, const dvec3 &curPoint, dvec3 prevTangent, dvec3 curTangent)
 
template dmat4 lastFrame (const dmat4 &prevMatrix, const dvec3 &prevPoint, const dvec3 &lastPoint)
 
geom::SourceRef loadGeom (const fs::path &path)
 
float nlerp (float t, float a, float b)
 
template<typename T >
linearYatX (const glm::tvec2< T, glm::defaultp > p[2], T x)
 
template<typename T >
size_t linearCrossings (const glm::tvec2< T, glm::defaultp > p[2], const vec2 &pt)
 
template<typename T >
std::ostream & operator<< (std::ostream &o, const RectT< T > &rect)
 
void lockToLogicalProcessor (int n)
 
void cpuidwrap (int *p, unsigned int param)
 
void cpuid (int whichlp, PLOGICALPROCESSORDATA p)
 
void * stdAlloc (void *userData, unsigned int size)
 
void stdFree (void *userData, void *ptr)
 
void safeInternetCloseHandle (HINTERNET hInternet)
 
void testAndThrowHttpStatus (HINTERNET hInternet)
 
void parseItem (const rapidxml::xml_node<> &node, XmlTree *parent, XmlTree *result, const XmlTree::ParseOptions &parseOptions)
 

Variables

const double EPSILON_VALUE = 4.37114e-05
 

Typedef Documentation

typedef std::shared_ptr< class Display > cinder::DisplayRef
typedef BSpline<2,float> cinder::BSpline2f
typedef BSpline<3,float> cinder::BSpline3f
typedef std::shared_ptr<class Buffer> cinder::BufferRef
typedef std::shared_ptr< class DataSource > cinder::DataSourceRef
typedef std::shared_ptr< class DataTarget > cinder::DataTargetRef
typedef std::shared_ptr<class Capture> cinder::CaptureRef
typedef std::shared_ptr< class ImageSource > cinder::ImageSourceRef
typedef ChannelT<uint8_t> cinder::Channel

8-bit image channel. Synonym for Channel8u.

typedef ChannelT<uint8_t> cinder::Channel8u

8-bit image channel

typedef std::shared_ptr<Channel8u> cinder::Channel8uRef
typedef std::shared_ptr<Channel8u> cinder::ChannelRef
typedef ChannelT<uint16_t> cinder::Channel16u

16-bit image channel. Suitable as an intermediate representation and ImageIo but not a first-class citizen.

typedef std::shared_ptr<Channel16u> cinder::Channel16uRef
typedef ChannelT<float> cinder::Channel32f

32-bit floating point image channel

typedef std::shared_ptr<Channel32f> cinder::Channel32fRef
typedef ColorT<float> cinder::Colorf
typedef ColorT<uint8_t> cinder::Color8u
typedef ColorAT<float> cinder::ColorA
typedef ColorAT<float> cinder::ColorAf
typedef ColorAT<uint8_t> cinder::ColorA8u
typedef std::shared_ptr<class DataSourcePath> cinder::DataSourcePathRef
typedef std::shared_ptr<class DataSourceUrl> cinder::DataSourceUrlRef
typedef std::shared_ptr<class DataSourceBuffer> cinder::DataSourceBufferRef
typedef std::shared_ptr<class DataTargetPath> cinder::DataTargetPathRef
typedef std::shared_ptr<class DataTargetStream> cinder::DataTargetStreamRef
typedef FrustumT<float> cinder::Frustum
typedef FrustumT<float> cinder::Frustumf
typedef FrustumT<double> cinder::Frustumd
typedef uint32_t cinder::CallbackId

Represents a unique identifier for a callback.

typedef std::shared_ptr<class ImageLoader> cinder::ImageLoaderRef
typedef std::shared_ptr< class ImageTarget > cinder::ImageTargetRef
typedef std::shared_ptr<class ImageTargetFile> cinder::ImageTargetFileRef
typedef std::shared_ptr< IStreamCinder > cinder::IStreamRef
typedef std::shared_ptr<class ImageSourceFileWic> cinder::ImageSourceFileWicRef
typedef std::shared_ptr<class ImageSourcePng> cinder::ImageSourcePngRef
typedef std::shared_ptr<class ImageTargetFileWic> cinder::ImageTargetFileWicRef
typedef PlaneT<float> cinder::Plane
typedef PlaneT<float> cinder::Planef
typedef PlaneT<double> cinder::Planed
typedef PolyLineT<dvec2> cinder::PolyLine2d
typedef PolyLineT<dvec3> cinder::PolyLine3d
typedef RectT<float> cinder::Rectf
typedef RectT<double> cinder::Rectd
typedef std::shared_ptr<class Serial> cinder::SerialRef
typedef std::shared_ptr<class OStream> cinder::OStreamRef
typedef std::shared_ptr<IoStream> cinder::IoStreamRef
typedef std::shared_ptr<class IStreamFile> cinder::IStreamFileRef
typedef std::shared_ptr<class OStreamFile> cinder::OStreamFileRef
typedef std::shared_ptr<class IoStreamFile> cinder::IoStreamFileRef
typedef std::shared_ptr<class IStreamMem> cinder::IStreamMemRef
typedef std::shared_ptr<class OStreamMem> cinder::OStreamMemRef
typedef SurfaceT<uint8_t> cinder::Surface

8-bit image. Synonym for Surface8u.

typedef SurfaceT<uint8_t> cinder::Surface8u

8-bit image

typedef std::shared_ptr<Surface8u> cinder::Surface8uRef
typedef std::shared_ptr<Surface8u> cinder::SurfaceRef
typedef SurfaceT<uint16_t> cinder::Surface16u

16-bit image. Suitable as an intermediate representation and ImageIo but not a first-class citizen.

typedef std::shared_ptr<Surface16u> cinder::Surface16uRef
typedef SurfaceT<float> cinder::Surface32f

32-bit floating point image

typedef std::shared_ptr<Surface32f> cinder::Surface32fRef
typedef std::shared_ptr<class Cue> cinder::CueRef
typedef std::shared_ptr< Timeline > cinder::TimelineRef
typedef std::shared_ptr<class TimelineItem> cinder::TimelineItemRef
typedef std::shared_ptr<class TriMesh> cinder::TriMeshRef
typedef std::function<float (float)> cinder::EaseFn
typedef std::shared_ptr<class IStreamUrl> cinder::IStreamUrlRef

A pointer to an instance of an IStreamUrl. Can be created using IStreamUrl::createRef()

typedef BSplineFit<float> cinder::BSplineFitf
typedef BSplineFit<double> cinder::BSplineFitd
typedef BSplineFitBasis<float> cinder::BSplineFitBasisf
typedef BSplineFitBasis<double> cinder::BSplineFitBasisd
typedef boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > cinder::polygon
typedef struct cinder::_LOGICALPROCESSORDATA cinder::LOGICALPROCESSORDATA
typedef struct cinder::_LOGICALPROCESSORDATA * cinder::PLOGICALPROCESSORDATA
typedef std::multimap<void*,TimelineItemRef>::iterator cinder::s_iter
typedef std::multimap<void*,TimelineItemRef>::const_iterator cinder::s_const_iter

Enumeration Type Documentation

Enumerator
CM_RGB 
CM_HSV 

Values returned by calcBreaksUtf8 and calcBreaksUtf16.

Enumerator
UNICODE_MUST_BREAK 
UNICODE_ALLOW_BREAK 
UNICODE_NO_BREAK 
UNICODE_INSIDE_CHAR 

Function Documentation

pair< Area, ivec2 > cinder::clippedSrcDst ( const Area srcSurfaceBounds,
const Area srcArea,
const Area dstSurfaceBounds,
const ivec2 &  dstLT 
)
std::string cinder::toBase64 ( const std::string &  input,
int  charsPerLine = 0 
)

Converts input into a Base64-encoded string. If charsPerLine > 0, carriage returns (
) are inserted every charsPerLine characters, rounded down to the nearest multiple of 4.

std::string cinder::toBase64 ( const Buffer input,
int  charsPerLine = 0 
)

Converts input into a Base64-encoded string. If charsPerLine > 0, carriage returns (
) are inserted every charsPerLine characters, rounded down to the nearest multiple of 4.

std::string cinder::toBase64 ( const void *  input,
size_t  inputSize,
int  charsPerLine = 0 
)

Converts input of length inputSize into a Base64-encoded string. If charsPerLine > 0, carriage returns (
) are inserted every charsPerLine characters, rounded down to the nearest multiple of 4.

Buffer cinder::fromBase64 ( const std::string &  input)

Converts Base64-encoded data input into unencoded data.

Buffer cinder::fromBase64 ( const Buffer input)

Converts Base64-encoded data input into unencoded data.

Buffer cinder::fromBase64 ( const void *  input,
size_t  inputSize 
)

Converts Base64-encoded data input into unencoded data.

template<int D, typename T >
BSpline< D, T > cinder::fitBSpline ( const std::vector< typename BSpline< D, T >::VecT > &  samples,
int  degree,
int  outputSamples 
)
Buffer cinder::compressBuffer ( const Buffer buffer,
int8_t  compressionLevel = DEFAULT_COMPRESSION_LEVEL,
bool  resizeResult = true 
)
Buffer cinder::decompressBuffer ( const Buffer buffer,
bool  resizeResult = true,
bool  useGZip = false 
)
float cinder::toRadians ( float  x)
double cinder::toRadians ( double  x)
float cinder::toDegrees ( float  x)
double cinder::toDegrees ( double  x)
template<typename T , typename L >
T cinder::lerp ( const T &  a,
const T &  b,
factor 
)
template<typename T >
T cinder::lmap ( val,
inMin,
inMax,
outMin,
outMax 
)
template<typename T , typename L >
T cinder::bezierInterp ( a,
b,
c,
d,
t 
)
template<typename T , typename L >
T cinder::bezierInterpRef ( const T &  a,
const T &  b,
const T &  c,
const T &  d,
t 
)
template<typename T >
T cinder::constrain ( val,
minVal,
maxVal 
)
template<typename T >
T cinder::fract ( x)

Returns the fractional part of x, calculated as x - floor( x )

template<class T >
T cinder::sinx_over_x ( x)
uint32_t cinder::log2floor ( uint32_t  x)
uint32_t cinder::log2ceil ( uint32_t  x)
uint32_t cinder::nextPowerOf2 ( uint32_t  x)
bool cinder::isPowerOf2 ( size_t  x)

Returns true if x is a power of two, false otherwise.

template<typename T >
int cinder::solveLinear ( a,
b,
result[1] 
)
template<typename T >
int cinder::solveQuadratic ( a,
b,
c,
result[2] 
)
template<typename T , int ORDER>
T cinder::rombergIntegral ( a,
b,
const std::function< T(T)> &  SPEEDFN 
)
template<typename T >
int cinder::solveCubic ( a,
b,
c,
d,
result[3] 
)
glm::vec2 cinder::getClosestPointEllipse ( const glm::vec2 center,
const glm::vec2 axisA,
const glm::vec2 axisB,
const glm::vec2 testPoint 
)

Returns the closest point to testPoint on the boundary of the ellipse defined by center, axisA and axisB. Algorithm due to David Eberly, http://www.geometrictools.com/Documentation/DistancePointEllipseEllipsoid.pdf.

cinder::half_float cinder::floatToHalf ( float  f)
float cinder::halfToFloat ( cinder::half_float  h)
template<typename T , typename Y >
ColorT<T> cinder::operator* ( s,
const ColorT< T > &  c 
)
template<typename T , typename Y >
ColorAT<T> cinder::operator* ( s,
const ColorAT< T > &  c 
)
Colorf cinder::hsvToRgb ( const vec3 &  hsv)
vec3 cinder::rgbToHsv ( const ColorT< float > &  c)
ColorT< uint8_t > cinder::svgNameToRgb ( const char *  svgName,
bool *  found = NULL 
)

Converts the named colors of the SVG spec http://en.wikipedia.org/wiki/Web_colors#X11_color_names to sRGB Color8u. If found is non-NULL, it's set to whether the name was located. Returns black on failure.

template<typename T >
float cinder::distance ( const ColorT< T > &  c0,
const ColorT< T > &  c1 
)
template<typename T >
float cinder::distance ( const ColorAT< T > &  c0,
const ColorAT< T > &  c1 
)
template<typename T >
CHANTRAIT<T>::Accum cinder::distance2 ( const ColorT< T > &  c0,
const ColorT< T > &  c1 
)
template<typename T >
CHANTRAIT<T>::Accum cinder::distance2 ( const ColorAT< T > &  c0,
const ColorAT< T > &  c1 
)
template<typename T >
float cinder::length ( const ColorT< T > &  c)
template<typename T >
float cinder::length ( const ColorAT< T > &  c)
template<typename T >
CHANTRAIT<T>::Accum cinder::length2 ( const ColorT< T > &  c)
template<typename T >
CHANTRAIT<T>::Accum cinder::length2 ( const ColorAT< T > &  c)
template<typename T >
CHANTRAIT<T>::Accum cinder::dot ( const ColorT< T > &  c0,
const ColorT< T > &  c1 
)
template<typename T >
CHANTRAIT<T>::Accum cinder::dot ( const ColorAT< T > &  c0,
const ColorAT< T > &  c1 
)
template<typename T >
ColorT<T> cinder::normalize ( const ColorT< T > &  c0)
template<typename T >
ColorAT<T> cinder::normalize ( const ColorAT< T > &  c0)
std::ostream & cinder::operator<< ( std::ostream &  lhs,
const ColorT< float > &  rhs 
)
std::ostream & cinder::operator<< ( std::ostream &  lhs,
const ColorAT< float > &  rhs 
)
std::ostream & cinder::operator<< ( std::ostream &  lhs,
const ColorT< uint8_t > &  rhs 
)
std::ostream & cinder::operator<< ( std::ostream &  lhs,
const ColorAT< uint8_t > &  rhs 
)
PolyLine2f cinder::calcConvexHull ( const std::vector< vec2 > &  points)
PolyLine2f cinder::calcConvexHull ( const vec2 *  points,
size_t  numPoints 
)
PolyLine2f cinder::calcConvexHull ( const Shape2d shape)
PolyLine2f cinder::calcConvexHull ( const Path2d path)
PolyLine2f cinder::calcConvexHull ( const PolyLine2f polyLine)
DataSourceRef cinder::loadFile ( const fs::path &  path)
DataSourceRef cinder::loadUrl ( const Url Url,
const UrlOptions options = UrlOptions() 
)
DataSourceRef cinder::loadUrl ( const std::string &  urlString,
const UrlOptions options = UrlOptions() 
)
DataTargetPathRef cinder::writeFile ( const fs::path &  path,
bool  createParents = true 
)

Returns a DataTarget to file path path, and optionally creates any necessary directories when createParents is true.

float cinder::easeNone ( float  t)

Easing equation for a simple linear tweening with no easing.

float cinder::easeInQuad ( float  t)

Easing equation for a quadratic (t^2) ease-in, accelerating from zero velocity.

float cinder::easeOutQuad ( float  t)

Easing equation for a quadratic (t^2) ease-out, decelerating to zero velocity.

float cinder::easeInOutQuad ( float  t)

Easing equation for a quadratic (t^2) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInQuad ( float  t)

Easing equation for a quadratic (t^2) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInCubic ( float  t)

Easing equation function for a cubic (t^3) ease-in, accelerating from zero velocity.

float cinder::easeOutCubic ( float  t)

Easing equation for a cubic (t^3) ease-out, decelerating to zero velocity.

float cinder::easeInOutCubic ( float  t)

Easing equation for a cubic (t^3) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInCubic ( float  t)

Easing equation for a cubic (t^3) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInQuart ( float  t)

Easing equation for a quartic (t^4) ease-in, accelerating from zero velocity.

float cinder::easeOutQuart ( float  t)

Easing equation for a quartic (t^4) ease-out, decelerating to zero velocity.

float cinder::easeInOutQuart ( float  t)

Easing equation for a quartic (t^4) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInQuart ( float  t)

Easing equation for a quartic (t^4) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInQuint ( float  t)

Easing equation function for a quintic (t^5) ease-in, accelerating from zero velocity.

float cinder::easeOutQuint ( float  t)

Easing equation for a quintic (t^5) ease-out, decelerating to zero velocity.

float cinder::easeInOutQuint ( float  t)

Easing equation for a quintic (t^5) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInQuint ( float  t)

Easing equation for a quintic (t^5) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInSine ( float  t)

Easing equation for a sinusoidal (sin(t)) ease-in, accelerating from zero velocity.

float cinder::easeOutSine ( float  t)

Easing equation for a sinusoidal (sin(t)) ease-out, decelerating from zero velocity.

float cinder::easeInOutSine ( float  t)

Easing equation for a sinusoidal (sin(t)) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInSine ( float  t)

Easing equation for a sinusoidal (sin(t)) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInExpo ( float  t)

Easing equation for an exponential (2^t) ease-in, accelerating from zero velocity.

float cinder::easeOutExpo ( float  t)

Easing equation for an exponential (2^t) ease-out, decelerating from zero velocity.

float cinder::easeInOutExpo ( float  t)

Easing equation for an exponential (2^t) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInExpo ( float  t)

Easing equation for an exponential (2^t) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInCirc ( float  t)

Easing equation for a circular (sqrt(1-t^2)) ease-in, accelerating from zero velocity.

float cinder::easeOutCirc ( float  t)

Easing equation for a circular (sqrt(1-t^2)) ease-out, decelerating from zero velocity.

float cinder::easeInOutCirc ( float  t)

Easing equation for a circular (sqrt(1-t^2)) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInCirc ( float  t)

Easing equation for a circular (sqrt(1-t^2)) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInBounce ( float  t,
float  a = 1.70158f 
)

Easing equation for a bounce (exponentially decaying parabolic bounce) ease-in, accelerating from zero velocity. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeOutBounce ( float  t,
float  a = 1.70158f 
)

Easing equation for a bounce (exponentially decaying parabolic bounce) ease-out, decelerating from zero velocity. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeInOutBounce ( float  t,
float  a = 1.70158f 
)

Easing equation for a bounce (exponentially decaying parabolic bounce) ease-in/out, accelerating until halfway, then decelerating. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeOutInBounce ( float  t,
float  a = 1.70158f 
)

Easing equation for a bounce (exponentially decaying parabolic bounce) ease-out/in, decelerating until halfway, then accelerating. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeInBack ( float  t,
float  s = 1.70158f 
)

Easing equation for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) ease-in, accelerating from zero velocity. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeOutBack ( float  t,
float  s = 1.70158f 
)

Easing equation for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) ease-out, decelerating from zero velocity. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeInOutBack ( float  t,
float  s = 1.70158f 
)

Easing equation for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) ease-in/out, accelerating until halfway, then decelerating. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeOutInBack ( float  t,
float  s 
)

Easing equation for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) ease-out/in, decelerating until halfway, then accelerating. The a parameter controls overshoot, the default producing a 10% overshoot.

float cinder::easeInElastic ( float  t,
float  amplitude,
float  period 
)

Easing equation for an elastic (exponentially decaying sine wave) ease-in, accelerating from zero velocity.

float cinder::easeOutElastic ( float  t,
float  amplitude,
float  period 
)

Easing equation for an elastic (exponentially decaying sine wave) ease-out, decelerating from zero velocity.

float cinder::easeInOutElastic ( float  t,
float  amplitude,
float  period 
)

Easing equation for an elastic (exponentially decaying sine wave) ease-in/out, accelerating until halfway, then decelerating.

float cinder::easeOutInElastic ( float  t,
float  amplitude,
float  period 
)

Easing equation for an elastic (exponentially decaying sine wave) ease-out/in, decelerating until halfway, then accelerating.

float cinder::easeInAtan ( float  t,
float  a = 15 
)

Easing equation for an atan ease-in, accelerating from zero velocity. Used by permssion from Chris McKenzie.

float cinder::easeOutAtan ( float  t,
float  a = 15 
)

Easing equation for an atan ease-out, decelerating from zero velocity. Used by permssion from Chris McKenzie.

float cinder::easeInOutAtan ( float  t,
float  a = 15 
)

Easing equation for an atan ease-in/out, accelerating until halfway, then decelerating. Used by permssion from Chris McKenzie.

ImageSourceRef cinder::loadImage ( const fs::path &  path,
ImageSource::Options  options = ImageSource::Options(),
std::string  extension = "" 
)

Loads an image from the file path path. Optional extension parameter allows specification of a file type. For example, "jpg" would force the file to load as a JPEG.

ImageSourceRef cinder::loadImage ( DataSourceRef  dataSource,
ImageSource::Options  options = ImageSource::Options(),
std::string  extension = "" 
)

Loads an image from dataSource. Optional extension parameter allows specification of a file type. For example, "jpg" would force the file to load as a JPEG.

void cinder::writeImage ( DataTargetRef  dataTarget,
const ImageSourceRef imageSource,
ImageTarget::Options  options = ImageTarget::Options(),
std::string  extension = "" 
)

Writes imageSource to dataTarget. Optional extension parameter allows specification of a file type. For example, "jpg" would force the file to load as a JPEG.

void cinder::writeImage ( const fs::path &  path,
const ImageSourceRef imageSource,
ImageTarget::Options  options = ImageTarget::Options(),
std::string  extension = "" 
)

Writes imageSource to file path path. Optional extension parameter allows specification of a file type. For example, "jpg" would force the file to load as a JPEG

Note
If path does not exist, the necessary directories are created automatically.
void cinder::writeImage ( ImageTargetRef  imageTarget,
const ImageSourceRef imageSource 
)

Writes imageSource to imageTarget.

ostream & cinder::operator<< ( std::ostream &  out,
const JsonTree json 
)
glm::mat4 cinder::transform2dTo3d ( const glm::mat3 m)
glm::mat4 cinder::alignZAxisWithTarget ( vec3  targetDir,
vec3  upDir 
)
template<typename T >
glm::tmat4x4< T, glm::defaultp > cinder::firstFrame ( const glm::tvec3< T, glm::defaultp > &  firstPoint,
const glm::tvec3< T, glm::defaultp > &  secondPoint,
const glm::tvec3< T, glm::defaultp > &  thirdPoint 
)
template<typename T >
glm::tmat4x4< T, glm::defaultp > cinder::nextFrame ( const glm::tmat4x4< T, glm::defaultp > &  prevMatrix,
const glm::tvec3< T, glm::defaultp > &  prevPoint,
const glm::tvec3< T, glm::defaultp > &  curPoint,
glm::tvec3< T, glm::defaultp prevTangent,
glm::tvec3< T, glm::defaultp curTangent 
)
template<typename T >
glm::tmat4x4< T, glm::defaultp > cinder::lastFrame ( const glm::tmat4x4< T, glm::defaultp > &  prevMatrix,
const glm::tvec3< T, glm::defaultp > &  prevPoint,
const glm::tvec3< T, glm::defaultp > &  lastPoint 
)
void cinder::writeObj ( const DataTargetRef dataTarget,
const geom::Source source,
bool  includeNormals = true,
bool  includeTexCoords = true 
)

Writes source to a new OBJ file to dataTarget.

void cinder::writeObj ( const DataTargetRef dataTarget,
const geom::SourceRef source,
bool  includeNormals = true,
bool  includeTexCoords = true 
)

Writes source to a new OBJ file to dataTarget.

std::ostream& cinder::operator<< ( std::ostream &  out,
const Path2d p 
)
template<typename T >
std::ostream& cinder::operator<< ( std::ostream &  o,
const PlaneT< T > &  p 
)
void cinder::randSeed ( uint32_t  seedValue)

Resets the static random generator to the specific seed seedValue.

bool cinder::randBool ( )

returns a random boolean value

int32_t cinder::randInt ( )

returns a random integer in the range [0,2147483647]

int32_t cinder::randInt ( int32_t  v)

returns a random integer in the range [0,v)

int32_t cinder::randInt ( int32_t  a,
int32_t  b 
)

returns a random integer in the range [a,b)

float cinder::randFloat ( )

returns a random float in the range [0.0f,1.0f]

float cinder::randFloat ( float  v)

returns a random float in the range [0.0f,v]

float cinder::randFloat ( float  a,
float  b 
)

returns a random float in the range [a,b]

float cinder::randPosNegFloat ( float  a,
float  b 
)

returns a random float in the range [a,b] or the range [-b,-a]

vec3 cinder::randVec3 ( )

returns a random vec3 that represents a point on the unit sphere

vec2 cinder::randVec2 ( )

returns a random vec2 that represents a point on the unit circle

float cinder::randGaussian ( )

returns a random float via Gaussian distribution

void cinder::getClippedScaledRects ( const Area srcSurfaceBounds,
const Rectf srcRect,
const Area dstSurfaceBounds,
const Area dstArea,
Rectf resultSrcRect,
Area resultDstRect 
)
IStreamFileRef cinder::loadFileStream ( const fs::path &  path)

Opens the file lcoated at path for read access as a stream.

std::shared_ptr< OStreamFile > cinder::writeFileStream ( const fs::path &  path,
bool  createParents = true 
)

Opens the file located at path for write access as a stream, and creates it if it does not exist. Optionally creates any intermediate directories when createParents is true.

IoStreamFileRef cinder::readWriteFileStream ( const fs::path &  path)

Opens a path for read-write access as a stream.

void cinder::loadStreamMemory ( IStreamRef  is,
std::shared_ptr< uint8_t > *  resultData,
size_t *  resultDataSize 
)

Loads the contents of a stream into a contiguous block of memory, pointed to by resultData. The size of this block is stored in resultDataSize.

BufferRef cinder::loadStreamBuffer ( IStreamRef  is)

Loads the contents of a stream into a ref counted Buffer.

std::ostream& cinder::operator<< ( std::ostream &  outp,
const System::NetworkAdapter adapter 
)
Surface cinder::renderString ( const std::string &  str,
const Font font,
const ColorA color,
float *  baselineOffset = 0 
)

Renders a single string and returns it as a Surface. Optional baselineOffset pointer will receive how many pixels of descender are in the returned Surface. Offset rendering the result Surface by this amount in order to preserve a consistent baseline. Consider gl::drawString() as a more convenient alternative.

template<typename T >
T cinder::tweenLerp ( const T &  start,
const T &  end,
float  time 
)
template<>
quat cinder::tweenLerp ( const quat &  start,
const quat &  end,
float  time 
)
template<>
dquat cinder::tweenLerp ( const dquat &  start,
const dquat &  end,
float  time 
)
std::u16string cinder::toUtf16 ( const char *  utf8Str,
size_t  lengthInBytes = 0 
)
std::u16string cinder::toUtf16 ( const std::string &  utf8Str)
std::u32string cinder::toUtf32 ( const char *  utf8Str,
size_t  lengthInBytes = 0 
)
std::u32string cinder::toUtf32 ( const std::string &  utf8Str)
std::string cinder::toUtf8 ( const char16_t *  utf16Str,
size_t  lengthInBytes = 0 
)
std::string cinder::toUtf8 ( const std::u16string &  utf16Str)
std::string cinder::toUtf8 ( const char32_t *  utf32str,
size_t  lengthInBytes = 0 
)
std::string cinder::toUtf8 ( const std::u32string &  utf32Str)
std::u16string cinder::toUtf16 ( const std::u32string &  utf32str)
std::u32string cinder::toUtf32 ( const std::u16string &  utf16str)
size_t cinder::stringLengthUtf8 ( const char *  str,
size_t  lengthInBytes = 0 
)

Returns the number of characters (not bytes) in the the UTF-8 string str. Optimize operation by supplying a non-default lengthInBytes of str.

uint32_t cinder::nextCharUtf8 ( const char *  str,
size_t *  inOutByte,
size_t  lengthInBytes = 0 
)

Returns the UTF-32 code point of the next character in str, relative to the byte inOutByte. Increments inOutByte to be the first byte of the next character. Optimize operation by supplying a non-default lengthInBytes of str.

size_t cinder::advanceCharUtf8 ( const char *  str,
size_t  numChars,
size_t  lengthInBytes = 0 
)

Returns the index in bytes of the next character in str, advanced by numChars characters. Optimize operation by supplying a non-default lengthInBytes of str.

void cinder::lineBreakUtf8 ( const char *  str,
const std::function< bool(const char *, size_t)> &  measureFn,
const std::function< void(const char *, size_t)> &  lineProcessFn 
)
void cinder::calcLinebreaksUtf8 ( const char *  str,
std::vector< uint8_t > *  resultBreaks 
)

Sets resultBreaks to be of the same length as the null-terminated UTF-8 string str with the values enumerated by UnicodeBreaks.

void cinder::calcLinebreaksUtf8 ( const char *  str,
size_t  strLength,
std::vector< uint8_t > *  resultBreaks 
)

Sets resultBreaks to be of the same length as the UTF-8 string str with the values enumerated by UnicodeBreaks.

void cinder::calcLinebreaksUtf16 ( const uint16_t *  str,
std::vector< uint8_t > *  resultBreaks 
)

Sets resultBreaks to be of the same length as the null-terminated UTF-16 string str with the values enumerated by UnicodeBreaks.

void cinder::calcLinebreaksUtf16 ( const uint16_t *  str,
size_t  strLength,
std::vector< uint8_t > *  resultBreaks 
)

Sets resultBreaks to be of the same length as the UTF-16 string str with the values enumerated by UnicodeBreaks.

std::ostream& cinder::operator<< ( std::ostream &  out,
const Url url 
)
std::istream& cinder::operator>> ( std::istream &  is,
Url url 
)
IStreamUrlRef cinder::loadUrlStream ( const Url url,
const UrlOptions options = UrlOptions() 
)
IStreamUrlRef cinder::loadUrlStream ( const std::string &  url,
const std::string &  user = "",
const std::string &  password = "",
const UrlOptions options = UrlOptions() 
)
fs::path cinder::expandPath ( const fs::path &  path)

Returns a canonical version of path. Collapses '.', ".." and "//". Converts '~' on Cocoa. Expands environment variables on MSW.

fs::path cinder::getHomeDirectory ( )

Returns a path to the user's home directory.

fs::path cinder::getDocumentsDirectory ( )

Returns a path to the user's documents directory.

void cinder::launchWebBrowser ( const Url url)

Launches a path in a web browser.

std::vector< std::string > cinder::split ( const std::string &  str,
char  separator,
bool  compress = true 
)

Returns a vector of substrings split by the separator separator. split( "one two three", ' ' ) -> [ "one", "two", "three" ] If compress is TRUE, it will consider consecutive separators as one.

std::vector< std::string > cinder::split ( const std::string &  str,
const std::string &  separators,
bool  compress = true 
)

Returns a vector of substrings split by the characters in separators. split( "one, two, three", " ," ) -> [ "one", "two", "three" ] If compress is TRUE, it will consider consecutive separators as one.

string cinder::loadString ( const DataSourceRef dataSource)

Loads the contents of dataSource and returns it as a std::string.

void cinder::sleep ( float  milliseconds)

Suspends the execution of the current thread until milliseconds have passed. Supports sub-millisecond precision only on Mac OS X.

char cinder::getPathSeparator ( )

Returns the path separator for the host operating system's file system, '\' on Windows and '/' on Mac OS.

std::map< std::string, std::string > cinder::getEnvironmentVariables ( )

Returns a std::map of the system's environment variables. Empty on WinRT.

template<typename T >
std::string cinder::toString ( const T &  t)
template<typename T >
T cinder::fromString ( const std::string &  s)
template<>
Url cinder::fromString ( const std::string &  s)
vector< string > cinder::stackTrace ( )

Returns a stack trace (aka backtrace) where stackTrace()[0] == caller, stackTrace()[1] == caller's parent, etc.

int8_t cinder::swapEndian ( int8_t  val)
uint8_t cinder::swapEndian ( uint8_t  val)
int16_t cinder::swapEndian ( int16_t  val)
uint16_t cinder::swapEndian ( uint16_t  val)
int32_t cinder::swapEndian ( int32_t  val)
uint32_t cinder::swapEndian ( uint32_t  val)
float cinder::swapEndian ( float  val)
double cinder::swapEndian ( double  val)
void cinder::swapEndianBlock ( uint16_t *  blockPtr,
size_t  blockSizeInBytes 
)
void cinder::swapEndianBlock ( float *  blockPtr,
size_t  blockSizeInBytes 
)
template<typename T , glm::precision P>
glm::tvec3<T, P> cinder::orthogonal ( const glm::tvec3< T, P > &  vec)

Returns a vector which is orthogonal to vec.

ostream & cinder::operator<< ( std::ostream &  out,
const XmlTree xml 
)

Streams the XmlTree xml to std::ostream out with standard formatting.

template<class T >
void cinder::allocate2D ( int  iCols,
int  iRows,
T **&  raatArray 
)
template<class T >
void cinder::deallocate2D ( T **&  raatArray)
template BSpline<2, float> cinder::fitBSpline ( const std::vector< vec2 > &  samples,
int  degree,
int  outputSamples 
)
template BSpline<3, float> cinder::fitBSpline ( const std::vector< vec3 > &  samples,
int  degree,
int  outputSamples 
)
template BSpline<4, float> cinder::fitBSpline ( const std::vector< vec4 > &  samples,
int  degree,
int  outputSamples 
)
template int cinder::solveCubic ( float  a,
float  b,
float  c,
float  d,
float  result[3] 
)
template int cinder::solveCubic ( double  a,
double  b,
double  c,
double  d,
double  result[3] 
)
vec2 cinder::getClosestPointEllipse ( const vec2 &  center,
const vec2 &  axisA,
const vec2 &  axisB,
const vec2 &  testPoint 
)
bool cinder::clipboardContainsFormat ( const std::set< UINT > &  formats)
int CALLBACK cinder::EnumFontFamiliesExProc ( ENUMLOGFONTEX *  lpelfe,
NEWTEXTMETRICEX *  lpntme,
int  FontType,
LPARAM  lParam 
)
template mat4 cinder::firstFrame ( const vec3 &  firstPoint,
const vec3 &  secondPoint,
const vec3 &  thirdPoint 
)
template mat4 cinder::nextFrame ( const mat4 &  prevMatrix,
const vec3 &  prevPoint,
const vec3 &  curPoint,
vec3  prevTangent,
vec3  curTangent 
)
template mat4 cinder::lastFrame ( const mat4 &  prevMatrix,
const vec3 &  prevPoint,
const vec3 &  lastPoint 
)
template dmat4 cinder::firstFrame ( const dvec3 &  firstPoint,
const dvec3 &  secondPoint,
const dvec3 &  thirdPoint 
)
template dmat4 cinder::nextFrame ( const dmat4 &  prevMatrix,
const dvec3 &  prevPoint,
const dvec3 &  curPoint,
dvec3  prevTangent,
dvec3  curTangent 
)
template dmat4 cinder::lastFrame ( const dmat4 &  prevMatrix,
const dvec3 &  prevPoint,
const dvec3 &  lastPoint 
)
geom::SourceRef cinder::loadGeom ( const fs::path &  path)
float cinder::nlerp ( float  t,
float  a,
float  b 
)
template<typename T >
T cinder::linearYatX ( const glm::tvec2< T, glm::defaultp p[2],
x 
)
template<typename T >
size_t cinder::linearCrossings ( const glm::tvec2< T, glm::defaultp p[2],
const vec2 &  pt 
)
template<typename T >
std::ostream& cinder::operator<< ( std::ostream &  o,
const RectT< T > &  rect 
)
void cinder::lockToLogicalProcessor ( int  n)
void cinder::cpuidwrap ( int *  p,
unsigned int  param 
)
void cinder::cpuid ( int  whichlp,
PLOGICALPROCESSORDATA  p 
)
void* cinder::stdAlloc ( void *  userData,
unsigned int  size 
)
void cinder::stdFree ( void *  userData,
void *  ptr 
)
void cinder::safeInternetCloseHandle ( HINTERNET  hInternet)
void cinder::testAndThrowHttpStatus ( HINTERNET  hInternet)
void cinder::parseItem ( const rapidxml::xml_node<> &  node,
XmlTree parent,
XmlTree result,
const XmlTree::ParseOptions parseOptions 
)

Variable Documentation

const double cinder::EPSILON_VALUE = 4.37114e-05