  ion::analytics::Benchmark::AccumulatedVariable | This struct represents accumulated values for a variable |
 ion::base::Allocatable | Allocatable is an abstract base class for classes whose memory is managed by an Allocator |
 ion::base::Array2< double > | |
| ion::base::CircularBuffer< uint32 > | |
| ion::base::Array2< T > | Simple rectangular 2D array class with range-checked indexing, templatized by the element type |
| ion::base::CircularBuffer< T > | Simple circular buffer class that has fixed capacity and does not grow automatically |
| ion::base::FunctionCallBase | FunctionCallBase does nothing but define a virtual operator() to allow containers of arbitrary FunctionCall<>s |
 ion::base::FunctionCall< ReturnType(Types...)> | Specialize for an arbitrary function signature |
| ion::base::MemoryZipStream | A MemoryZipStream represents ZIP data in memory; the data may represent one or more files or directories in ZIP format |
| ion::base::Referent | Thread-safe abstract base class |
| ion::base::CallList | CallList contains a list of function calls to execute |
| ion::base::WeakReferent | Abstract base class that inherits from Referent, and adds the ability for instances to be referenced by a WeakReferentPtr |
 ion::base::Notifier | A Notifier both sends notifications to and receives notifications from other Notifiers |
 ion::base::DataContainer | Encapsulates arbitrary user data passed to Ion |
| ion::base::VectorDataContainer< T > | VectorDataContainer is a special kind of DataContainer that is backed by an AllocVector |
| ion::gfx::Image | An Image represents 2D image data that can be used in a texture supplied to a shader |
| ion::gfx::ResourceHolder | ResourceHolder is an internal base class for objects that hold resources managed by an outside entity, such as ResourceManager, allowing the resources to be associated opaquely with an instance of the object |
| ion::gfx::AttributeArray | An AttributeArray represents a collection of Attributes used to describe the vertices of a Shape |
| ion::gfx::BufferObject | A BufferObject describes a generic array of data used, for example, to describe the vertices in a Shape or data retrieved from a framebuffer |
| ion::gfx::IndexBuffer | An IndexBuffer is a type of BufferObject that contains the element indices of an array, e.g., a vertex index array |
| ion::gfx::FramebufferObject | A FramebufferObject describes an off-screen framebuffer that can be drawn to and read from like a regular framebuffer |
| ion::gfx::Sampler | A Sampler object represents texture parameters that control how texture data is accessed in shaders |
| ion::gfx::ShaderBase | Base class for Shader and ShaderProgram objects |
| ion::gfx::Shader | A Shader represents an OpenGL shader stage |
| ion::gfx::ShaderProgram | A ShaderProgram represents an OpenGL shader program that can be applied to shapes |
| ion::gfx::ShaderInputRegistry | A ShaderInputRegistry is used to manage a collection of shader inputs to a specific ShaderProgram (both uniforms and attributes) |
| ion::gfx::TextureBase | This is an internal base class for all texture types |
| ion::gfx::CubeMapTexture | A CubeMapTexture object represents the image data and mipmaps associated with the six faces of a cube map |
| ion::gfx::Texture | A Texture object represents the image data and mipmaps associated with a single texture |
| ion::gfx::UniformBlock | A UniformBlock is a grouping of uniforms that can be easily shared between multiple Nodes; changing a Uniform in a UniformBlock will thus automatically change it for all Nodes that share the block |
| ion::gfx::GraphicsManager | GraphicsManager manages the graphics library for an application |
| ion::gfx::Node | A Node instance represents a node in a scene graph |
| ion::gfx::Renderer | Handles rendering ION scene graphs using OpenGL |
| ion::gfx::Shape | A Shape object represents a shape (vertices + indices) to draw |
| ion::gfx::StateTable | A StateTable represents a collection of graphical state items that affect OpenGL rendering |
| ion::gfxutils::Frame | Frame manages an application-defined frame of execution |
| ion::gfxutils::ResourceCallback< T > | Class that allows blocking until a callback is called and automagically destroys itself after both Callback() and WaitForCompletion() have executed |
| ion::gfxutils::ShaderManager | ShaderManager contains an association between shader programs, their names, and any source dependencies they have |
| ion::gfxutils::ShaderSourceComposer | A ShaderSourceComposer is a generic interface for constructing a shader source string |
| ion::gfxutils::FilterComposer | Applies a fixed transformation to the output of another composer |
| ion::gfxutils::IncludeComposer | Loads a shader source from a resource that may include other resources using the special directive '$input "name"' |
| ion::gfxutils::ZipAssetComposer | Loads a shader source from zip asset resources that may $input other zip assets |
| ion::gfxutils::StringComposer | Simple composer that just returns the string passed to its constructor |
| ion::image::NinePatch | Represents a nine-patch image as described in the Android SDK reference |
| ion::remote::HttpServer::RequestHandler | RequestHandlers handle requests for a file or path |
| ion::remote::CallTraceHandler | CallTraceHandler serves a snapshot of the current call trace |
| ion::remote::NodeGraphHandler | NodeGraphHandler serves files to display Ion node graphs as text or HTML using the gfxutils::Printer class |
| ion::remote::ResourceHandler | ResourceHandler serves files related to OpenGL resources |
| ion::remote::SettingHandler | SettingHandler serves files related to Settings, including an interface for viewing and modifying them |
| ion::remote::ShaderHandler | ShaderHandler serves files related to shaders, their dependencies, and the shader editor |
| ion::remote::TracingHandler | TracingHandler serves files related to OpenGL tracing |
| ion::remote::HttpServer::Websocket | Represents the server side of a connected Websocket |
| ion::text::Builder | Builder is an abstract base class for building graphics objects used to render text |
| ion::text::BasicBuilder | BasicBuilder is a derived Builder class that uses a very basic shader to render text |
| ion::text::OutlineBuilder | OutlineBuilder is a derived Builder class that can render text with outlines |
| ion::text::Font | Font is a base class for implementation-specific representations of fonts |
| ion::text::CoreTextFont | This represents a single CoreText font |
| ion::text::FreeTypeFont | This derived Font class represents a FreeType2 font |
| ion::text::FontImage | A FontImage contains image and texture coordinate information used to render font glyphs |
| ion::text::DynamicFontImage | DynamicFontImage is a derived FontImage that may contain any number of ImageData instances |
| ion::text::StaticFontImage | StaticFontImage is a derived FontImage that contains a single ImageData instance that is created by the constructor and that cannot be modified afterward |
| ion::text::FontManager | The FontManager provides the main interface for fonts used to create text strings to render |
| ion::base::WorkerPool | Manages one or more threads that run in a loop, performing some work with each iteration (if any work is available) |
| ion::gfx::ResourceManager | A ResourceManager is an interface for getting information about a Renderer's internal resources |
| ion::gfx::TextureManager | TextureManager is an internal Ion class, and is not exported for public use |
| ion::profile::CallTraceManager | Manages call trace recording for visualization in Web Tracing Framework (WTF) format |
| ion::profile::TraceRecorder | Class for recording frame events |
| ion::base::AllocationManager | AllocationManager is a singleton class that is used to manage Allocators used to allocate Ion objects |
| std::allocator< T > | STL class |
| ion::base::StlAllocator< T > | StlAllocator is derived std::allocator class that allows an Ion Allocator to be used for STL containers |
| ion::base::StlInlinedAllocator< T, N > | StlInlinedAllocator is a derived StlAllocator class that uses inlined storage for its first N elements, then uses an Ion Allocator if that size is exceeded |
| ion::math::Angle< T > | A simple class to represent angles |
| ion::base::Variant< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40 >::ArrayAccessor | ArrayAccessor lets callers use operator[] with a Variant in most simple cases, as opposed to using the SetValueAt(i) and GetValueAt(i) functions above |
| ion::gfx::FramebufferObject::Attachment | An attachment represents a data store attached to one of the framebuffer's targets |
| ion::gfx::FramebufferInfo< T >::Attachment | |
| ion::gfx::ArrayInfo< T >::Attribute | |
| ion::gfx::ProgramInfo< T >::Attribute | An attribute to a vertex shader |
| ion::port::Barrier | Defines a multi-thread barrier that allows N threads to synchronize execution |
| ion::analytics::Benchmark | Types and utilities to make it easier to create performance benchmarks |
| ion::text::BinPacker | This class implements generic 2D bin-packing using a modified version of the Skyline Bottom-Left algorithm available at: http://clb.demon.fi/files/RectangleBinPack |
| ion::base::BoolType< b > | BoolType is a struct whose value member is either true or false |
| ion::base::BoolType< false > | |
| ion::base::IsSameType< T, U > | IsSameType is similar to std::is_same |
| ion::base::BoolType< IsSameType< To, From >::value||IsBaseOf< To, From >::value > | |
| ion::base::IsConvertible< From, To > | IsConvertible is similar to std::is_convertible, except that it only looks at direct inheritance relationships (e.g |
| ion::base::BoolType< true > | |
| ion::base::IsSameType< T, T > | |
| ion::gfx::BufferObjectElement | Structure for clients to use to encapsulate Elements |
| ion::gfx::BufferObject::BufferSubData | Specifies a destination byte range, read byte offset, and source BufferObject or DataContainer for BufferSubData and CopyBufferSubData |
| ion::gfxutils::BufferToAttributeBinder< T > | BufferToAttributeBinder is a simple interface to insert a set of Attributes containing BufferObjectElements into a AttributeArray, and also create the corresponding Elements in the BufferObject |
| ion::gfx::ShaderInputRegistry::CombineFunction< T > | This type defines a function that is used to combine values for two instances of a registered shader input |
| ion::base::ConditionalType< condition, A, B > | ConditionalType is similar to std::conditional |
| ion::base::ConditionalType< false, A, B > | |
| TimelineSearch::const_iterator | |
| Timeline::const_iterator | Traverses the hierarchy in pre-order |
| ion::analytics::Benchmark::Constant | This struct represents a number that is constant over all samples |
| ion::gfx::ResourceManager::DataRequest< InfoType > | Wrapper struct for data requests |
| ion::gfx::ResourceManager::DataRequest< ion::gfx::ResourceManager::PlatformInfo > | |
| ion::gfx::ResourceManager::DataRequest< ion::gfx::ResourceManager::TextureImageInfo > | |
| ion::base::DateTime | DateTime represents a particular date and time down to the nanosecond level along with timezone information |
| std::deque< T > | STL class |
| ion::base::AllocDeque< ion::gfx::ShaderInputRegistry::Spec > | |
| ion::base::AllocDeque< Uniform > | |
| ion::base::AllocDeque< T > | This class can be used in place of std::deque to allow an Ion Allocator to be used for memory allocation |
| ion::analytics::Benchmark::Descriptor | This struct stores information about a measurement computed by benchmarking |
| ion::base::internal_variant_utils::EmptyType< N > | Taken from util/gtl/emptytype.h |
| ion::base::EnumHelper | }; static const char* kStrings[] = { "Value1", "Value2", "Value3" }; return EnumData<Values>(IndexMap<Values, uint32>(kValues, 3), kStrings); } |
| ion::gfx::TextureBase::Face | Internal class that wraps texture data: a single image or a stack of mipmaps, and any sub- or layered data |
| ion::base::internal_variant_utils::FalseType | |
| ion::base::internal_variant_utils::is_emptytype< T > | |
| ion::gfx::ResourceHolder::FieldBase | Base class for Fields (see below) |
| ion::gfx::ResourceHolder::Field< std::string > | |
| ion::gfx::ResourceHolder::Field< T > | A generic field that represents some state in the resource |
| ion::gfx::ResourceHolder::RangedField< T > | A Field that has a limited valid range of values |
| ion::gfx::ResourceHolder::VectorField< T > | A Field that holds a vector of up to some number of values |
| ion::math::FieldOfView< T > | Encapsulates a generalized, asymmetric field of view with four half angles |
| ion::text::Font::FontMetrics | This struct represents the cumulative metrics for the font |
| ion::text::FreeTypeFontTransformData | This contains the values needed to transform glyph rectangles into the correct coordinates |
| ion::base::FunctionCall< T > | FunctionCall wraps an arbitrary call to a function, including its arguments |
| ion::gfx::ShaderInputRegistry::GenerateFunction< T > | A GenerateFunction is similar to a CombineFunction, above, but generates additional inputs based on the value of a single input |
| ion::base::GenericLockGuardBase< MutexT > | This file contains utility classes for automatically locking and unlocking mutexes |
| ion::base::GenericLockGuard< MutexT > | A LockGuard locks a mutex when created, and unlocks it when destroyed |
| ion::base::GenericTryLockGuard< MutexT > | A TryLockGuard attempts to lock a mutex when created, and if successful, will unlock it when destroyed |
| ion::base::GenericLockGuardBase< port::Mutex > | |
| ion::base::ManualLockGuard< T > | A ManualLockGuard can be used to protect a variable with a mutex in situations where it is not possible for scoping to be used |
| ion::base::GenericUnlockGuard< MutexT > | An UnlockGuard is the reverse of a LockGuard; it unlocks a mutex when created and locks it when destroyed |
| ion::gfx::GraphicsManager::GlVersions | Simple wrapper for a set of GL versions |
| ion::text::Layout::Glyph | A Glyph represents one character glyph in the layout |
| ion::text::Font::GlyphGrid | A grid representing a rendered glyph, with each grid pixel representing pixel coverage in the range (0,1) |
| ion::text::FreeTypeFont::GlyphMetrics | This struct represents the metrics for a single glyph |
| ion::analytics::GpuPerformanceTester | GPUPerformanceTester measures basic GPU rendering characteristics |
| ion::gfxprofile::GpuProfiler | Singleton class that augments CallTraceManager with GPU tracing support |
| ion::base::HasTrivialDestructor< T > | HasTrivialDestructor is similar to std::has_trivial_destructor or std::is_trivially_destructible |
| ion::base::IsBaseOf< Base, Derived >::Helper | Because the Derived type-cast operator is non-const, it is preferred over the Base operator when calling Test() below |
| ion::remote::HttpClient | HttpClient is a very basic class that sends HTTP requests and returns the server's response |
| ion::remote::HttpServer | |
| ion::remote::RemoteServer | A RemoteServer starts an HttpServer with a predefined handler for the /ion subdirectory |
| ion::text::FontImage::ImageData | Data for each image in the FontImage |
| ion::base::IndexMap< OrderedIndexType, UnorderedIndexType > | This template class can be used to map between two kinds of indices when the following assumptions apply: |
| ion::base::IndexMap< EnumType, uint32 > | |
| ion::gfx::ResourceManager::InfoCallback< T > | Callbacks called when requested resource information is available |
| ion::gfx::ResourceManager::InfoCallback< InfoType > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::ArrayInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::BufferInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::FramebufferInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::ProgramInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::ResourceManager::PlatformInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::ResourceManager::TextureImageInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::SamplerInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::ShaderInfo > | |
| ion::gfx::ResourceManager::InfoCallback< ion::gfx::TextureInfo > | |
| ion::analytics::IntervalDiscrepancy | Result of a discrepancy computation, including the value measured and the bounds of the interval where that value was measured |
| ion::base::IsBaseOf< Base, Derived > | IsBaseOf is similar to std::is_base_of |
| ion::base::internal::IsSameOrDerivedFrom< T, Base > | Helper structs |
| ion::text::Layout | A Layout instance specifies how glyphs are arranged to form text |
| ion::text::LayoutOptions | This struct defines parameters affecting layout of a single text string when passed to BuildLayout() |
| ion::base::Lazy< T > | Lazily populates a value |
| ion::base::SettingBase::ListenerInfo | |
| ion::port::android::LocalFrame | Pushes and pops a JNI local reference frame |
| ion::port::LogEntryWriter | Abstract class which can be overridden to integrate Ion logging with other logging systems |
| ion::base::LogChecker | Can be used inside unit tests to trap all log output and verify that it matches what is expected |
| ion::base::NullLogEntryWriter | A NullLogEntryWriter can be used completely disable all logging programmatically as long as it exists |
| ion::base::logging_internal::Logger | This class is used for regular logging |
| ion::base::internal_variant_utils::ManualConstructor< Type > | Simplification of util/gtl/manual_constructor.h |
| ion::base::internal_variant_utils::ManualConstructor< float > | |
| ion::base::internal_variant_utils::ManualConstructor< GLfloat > | |
| ion::base::internal_variant_utils::ManualConstructor< GLint > | |
| ion::base::internal_variant_utils::ManualConstructor< GraphicsManager::ShaderPrecision > | |
| ion::base::internal_variant_utils::ManualConstructor< int > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 10 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 11 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 12 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 13 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 14 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 15 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 16 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 17 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 18 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 19 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 20 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 21 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 22 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 23 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 24 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 25 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 26 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 27 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 28 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 29 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 30 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 31 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 32 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 33 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 34 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 35 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 36 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 37 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 38 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 39 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 40 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 7 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 8 > > | |
| ion::base::internal_variant_utils::ManualConstructor< internal_variant_utils::EmptyType< 9 > > | |
| ion::base::internal_variant_utils::ManualConstructor< math::Matrix2f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::Matrix3f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::Matrix4f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::Range1f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::Range1i > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase2f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase2i > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase2ui > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase3f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase3i > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase3ui > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase4f > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase4i > | |
| ion::base::internal_variant_utils::ManualConstructor< math::VectorBase4ui > | |
| ion::base::internal_variant_utils::ManualConstructor< std::vector< GLint > > | |
| ion::base::internal_variant_utils::ManualConstructor< T1 > | |
| ion::base::internal_variant_utils::ManualConstructor< T10 > | |
| ion::base::internal_variant_utils::ManualConstructor< T11 > | |
| ion::base::internal_variant_utils::ManualConstructor< T12 > | |
| ion::base::internal_variant_utils::ManualConstructor< T13 > | |
| ion::base::internal_variant_utils::ManualConstructor< T14 > | |
| ion::base::internal_variant_utils::ManualConstructor< T15 > | |
| ion::base::internal_variant_utils::ManualConstructor< T16 > | |
| ion::base::internal_variant_utils::ManualConstructor< T17 > | |
| ion::base::internal_variant_utils::ManualConstructor< T18 > | |
| ion::base::internal_variant_utils::ManualConstructor< T19 > | |
| ion::base::internal_variant_utils::ManualConstructor< T2 > | |
| ion::base::internal_variant_utils::ManualConstructor< T20 > | |
| ion::base::internal_variant_utils::ManualConstructor< T21 > | |
| ion::base::internal_variant_utils::ManualConstructor< T22 > | |
| ion::base::internal_variant_utils::ManualConstructor< T23 > | |
| ion::base::internal_variant_utils::ManualConstructor< T24 > | |
| ion::base::internal_variant_utils::ManualConstructor< T25 > | |
| ion::base::internal_variant_utils::ManualConstructor< T26 > | |
| ion::base::internal_variant_utils::ManualConstructor< T27 > | |
| ion::base::internal_variant_utils::ManualConstructor< T28 > | |
| ion::base::internal_variant_utils::ManualConstructor< T29 > | |
| ion::base::internal_variant_utils::ManualConstructor< T3 > | |
| ion::base::internal_variant_utils::ManualConstructor< T30 > | |
| ion::base::internal_variant_utils::ManualConstructor< T31 > | |
| ion::base::internal_variant_utils::ManualConstructor< T32 > | |
| ion::base::internal_variant_utils::ManualConstructor< T33 > | |
| ion::base::internal_variant_utils::ManualConstructor< T34 > | |
| ion::base::internal_variant_utils::ManualConstructor< T35 > | |
| ion::base::internal_variant_utils::ManualConstructor< T36 > | |
| ion::base::internal_variant_utils::ManualConstructor< T37 > | |
| ion::base::internal_variant_utils::ManualConstructor< T38 > | |
| ion::base::internal_variant_utils::ManualConstructor< T39 > | |
| ion::base::internal_variant_utils::ManualConstructor< T4 > | |
| ion::base::internal_variant_utils::ManualConstructor< T40 > | |
| ion::base::internal_variant_utils::ManualConstructor< T5 > | |
| ion::base::internal_variant_utils::ManualConstructor< T6 > | |
| ion::base::internal_variant_utils::ManualConstructor< T7 > | |
| ion::base::internal_variant_utils::ManualConstructor< T8 > | |
| ion::base::internal_variant_utils::ManualConstructor< T9 > | |
| ion::base::internal_variant_utils::ManualConstructor< uint32 > | |
| std::map< K, T > | STL class |
| ion::base::AllocMap< const std::string, SpecMapEntry > | |
| ion::base::AllocMap< const void *, size_t > | |
| ion::base::AllocMap< CTFontRef, uint16 > | |
| ion::base::AllocMap< GlyphIndex, GlyphGrid > | |
| ion::base::AllocMap< GlyphIndex, GlyphMetaData > | |
| ion::base::AllocMap< GlyphIndex, math::Range2f > | |
| ion::base::AllocMap< std::string, Callback > | |
| ion::base::AllocMap< std::string, FileInfo > | |
| ion::base::AllocMap< std::string, FontImagePtr > | |
| ion::base::AllocMap< std::string, FontPtr > | |
| ion::base::AllocMap< std::string, ProgramInfo > | |
| ion::base::AllocMap< std::string, unsigned int > | |
| ion::base::AllocMap< uint16, CTFontRef > | |
| ion::base::AllocMap< uint32, uint32 > | |
| ion::base::AllocMap< unsigned int, std::string > | |
| ion::base::AllocMap< void *, size_t > | |
| ion::base::AllocMap< K, V, Compare > | This class can be used in place of std::map to allow an Ion Allocator to be used for memory allocation |
| ion::math::Matrix< Dimension, T > | The Matrix class defines a square N-dimensional matrix |
| ion::analytics::GpuPerformanceTester::Measurement | |
| ion::port::MemoryMappedFile | Read-only in-memory view of an entire file on disk |
| ion::port::Mutex | A Mutex is used to ensure that only one thread or process can access a block of code at one time |
| ion::base::logging_internal::NullLogger | This class is used to disable logging, while still allowing for log messages to contain '<<' expressions |
| ion::base::OnceFlag | OnceFlag ensures that a target function is only evaluated once |
| ion::gfx::Image::PixelFormat | Struct representing the GL types for a particular Format (see above) |
| ion::gfx::ResourceManager::PlatformInfo | Struct for getting information about the local OpenGL platform |
| ion::gfxutils::Printer | Can be used for debugging |
| ion::text::Layout::Quad | A Quad represents a 3D quadrilateral onto which a character glyph in the layout will be drawn |
| ion::base::DateTime::Range | A class to contain a beginning and ending DateTime |
| ion::math::Range1TWrapper< T, N > | This struct allows the Endpoint and Size types in a Range<1, T> to be treated like those of higher-dimension Range classes (specifically the use of index operators) to simplify templated functions that use them |
| ion::math::RangeBase< Dimension, T > | The RangeBase class makes it possible to treat Ranges with Dimension=1 specially |
| ion::math::Range< Dimension, T > | The Range class defines an N-dimensional interval defined by minimum and maximum N-dimensional endpoints |
| ion::math::RangeBase< 1, T > | Specialize for Dimension=1 |
| ion::base::ReadLock | A ReadLock obtains a read lock, but has a similar interface to a Mutex and can be used with a ReadGuard |
| ion::base::ReadWriteLock | Defines a non-promotable lock that is very fast when only readers try to obtain the lock, but slower than a Mutex when there are writers |
| ion::base::StlInlinedAllocator< T, N >::rebind< U > | |
| ion::base::StlAllocator< T >::rebind< U > | |
| ion::base::StlInlinedAllocator< T, N >::RebindHelper< U, V > | Windows uses transient proxy allocators |
| ion::base::StlInlinedAllocator< T, N >::RebindHelper< U, U > | Specialize for when the types are the same, that is, for the primary T allocator |
| ion::text::BinPacker::Rectangle | Structure representing a rectangle to pack into the bin |
| ion::base::ReferentPtr< T > | A ReferentPtr is a smart shared pointer to an instance of some class derived from Referent |
| ion::base::ReferentPtr< AttributeArray > | |
| ion::base::ReferentPtr< BufferObject > | |
| ion::base::ReferentPtr< CubeMapTexture > | |
| ion::base::ReferentPtr< DataContainer > | |
| ion::base::ReferentPtr< Font > | |
| ion::base::ReferentPtr< FontImage > | |
| ion::base::ReferentPtr< Frame > | |
| ion::base::ReferentPtr< GraphicsManager > | |
| ion::base::ReferentPtr< HolderType > | |
| ion::base::ReferentPtr< Image > | |
| ion::base::ReferentPtr< IndexBuffer > | |
| ion::base::ReferentPtr< ion::base::WeakReferent::Proxy > | |
| ion::base::ReferentPtr< ion::gfx::AttributeArray > | |
| ion::base::ReferentPtr< ion::gfx::BufferObject > | |
| ion::base::ReferentPtr< ion::gfx::FramebufferObject > | |
| ion::base::ReferentPtr< ion::gfx::Sampler > | |
| ion::base::ReferentPtr< ion::gfx::Shader > | |
| ion::base::ReferentPtr< ion::gfx::ShaderProgram > | |
| ion::base::ReferentPtr< ion::gfx::TextureBase > | |
| ion::base::ReferentPtr< Node > | |
| ion::base::ReferentPtr< NodeGraphHandler > | |
| ion::base::ReferentPtr< Renderer > | |
| ion::base::ReferentPtr< ResourceCallback< T > > | |
| ion::base::ReferentPtr< Sampler > | |
| ion::base::ReferentPtr< ShaderInputRegistry > | |
| ion::base::ReferentPtr< ShaderManager > | |
| ion::base::ReferentPtr< ShaderProgram > | |
| ion::base::ReferentPtr< ShaderSourceComposer > | |
| ion::base::ReferentPtr< StateTable > | |
| ion::base::ReferentPtr< Texture > | |
| ion::base::ReferentPtr< TextureBase > | |
| ion::base::ReferentPtr< Websocket > | |
| ion::base::internal::ResolverHelper< VariantType, TypeToResolve, Base > | This struct is specialized for each of the defined types supported by a Variant |
| ion::gfx::ResourceBase | ResourceBase is an internal abstract base class for managed resources |
| ResourceInfo | |
| ion::gfx::RenderbufferInfo< ResourceInfo > | |
| ion::gfx::ResourceManager::ResourceInfo | Resource info types |
| ion::gfx::ResourceManager::ArrayResourceInfo | The below info types contain additional informative fields about resources |
| ion::gfx::ResourceManager::BufferTargetInfo | |
| ion::gfx::ResourceManager::FramebufferResourceInfo | |
| ion::gfx::ResourceManager::TextureResourceInfo | |
| ion::gfx::ResourceManager::ResourceRequest< HolderType, InfoType > | Wrapper struct for resource info requests |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::AttributeArray, ion::gfx::ArrayInfo > | |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::BufferObject, ion::gfx::BufferInfo > | |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::FramebufferObject, ion::gfx::FramebufferInfo > | |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::Sampler, ion::gfx::SamplerInfo > | |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::Shader, ion::gfx::ShaderInfo > | |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::ShaderProgram, ion::gfx::ProgramInfo > | |
| ion::gfx::ResourceManager::ResourceRequest< ion::gfx::TextureBase, ion::gfx::TextureInfo > | |
| ion::remote::HttpClient::Response | |
| ion::math::Rotation< T > | The Rotation class represents a rotation around a 3-dimensional axis |
| ion::analytics::Benchmark::Sample | This struct represents a single timestamped value of a variable |
| ion::analytics::Benchmark::SampledVariable | This struct represents a variable: a number that may vary over samples, such as a count or timing |
| ion::analytics::SampleMapping | Helper class for transforming samples between the time domain and the (unitless) normalized domain used for discrepancy calculation |
| ion::base::ScopedAllocation< T > | This template class can be used in situations where you want to allocate an object that is not necessarily derived from Allocatable, but you still want to use an Allocator for the memory |
| ion::profile::ScopedFrameTracer | Class to automatically record frame start and end events using the given TraceRecorder |
| ion::gfxprofile::ScopedGlTracer | Traces the GPU start and end times of the GL commands submitted in the same scope |
| ion::port::android::ScopedJObject | Stack-allocate this to clean up a jobject at end of scope |
| ion::base::ScopedSettingValue< T > | Sets a Setting<T> to a new value |
| ion::port::android::ScopedTrace | |
| ion::profile::ScopedTracer | Class to automatically record scope start and end events using the given TraceRecorder |
| ion::port::Semaphore | A Semaphore enables threads and process synchronization |
| Sequence | |
| std::set< K > | STL class |
| ion::base::AllocSet< GlyphIndex > | |
| ion::base::AllocSet< ion::port::ThreadId > | |
| ion::base::AllocSet< ShaderProgramResource * > | |
| ion::base::AllocSet< std::string > | |
| ion::base::AllocSet< T, Compare > | This class can be used in place of std::set to allow an Ion Allocator to be used for memory allocation |
| ion::base::SettingBase | Base class for Setting, which encapsulates the name of the setting and any functors that should be called via NotifyListeners() |
| ion::base::Setting< T > | Forward references |
| ion::base::EnvironmentSetting< T > | An EnvironmentSetting is a Setting can take its initial value from the named system environment variable passed to its constructor |
| ion::base::Setting< std::atomic< T > > | Specialize for std::atomic types |
| ion::base::Setting< bool > | |
| ion::base::SettingGroup | A SettingGroup is a convenience class to hold Settings that are in the same hierarchical group |
| ion::base::SettingManager | SettingManager tracks all existing SettingBase instances, and allows callers to obtain a map of all settings, get a specific setting or listen for when any setting in a group changes |
| ion::gfx::ShaderInputBase | |
| ion::gfx::ShaderInput< ValueHolderType, ValueEnumType > | A ShaderInput instance represents a general shader input |
| ion::gfx::ShaderInput< AttributeValueType, AttributeType > | |
| ion::gfx::Attribute | |
| ion::gfx::ShaderInput< UniformValueType, UniformType > | |
| ion::gfx::Uniform | A Uniform instance represents a uniform shader argument |
| ion::gfx::GraphicsManager::ShaderPrecision | Information about shader precision, see below |
| ion::gfxutils::ShapeSpec | This struct contains specifications common to all basic shapes |
| ion::gfxutils::BoxSpec | Box |
| ion::gfxutils::CylinderSpec | Cylinder |
| ion::gfxutils::EllipsoidSpec | Ellipsoid |
| ion::gfxutils::ExternalShapeSpec | External geometry formats |
| ion::gfxutils::PlanarShapeSpec | Planar shape |
| ion::gfxutils::RectangleSpec | Rectangle |
| ion::gfxutils::RegularPolygonSpec | Regular polygon |
| ion::base::Shareable | Shareable is an abstract base class for any object that can be shared via the SharedPtr class |
| ion::base::AllocationTracker | AllocationTracker is an abstract base class for objects that track memory |
| ion::base::AllocationSizeTracker | AllocationSizeTracker is an abstract base class for objects that track memory |
| ion::base::FullAllocationTracker | FullAllocationTracker is a derived AllocationTracker class that keeps track of all active allocations and also provides tracing facilities for debugging and error checking of leaked allocations |
| ion::base::Allocator | Allocator is an abstract base class for a memory allocator used for Ion objects derived from Allocatable |
| ion::base::Referent | Thread-safe abstract base class |
| ion::base::StaticDeleterDeleter | StaticDeleterDeleter is an internal class that holds and deletes StaticDeleters; it should not be used directly |
| ion::base::SharedPtr< T > | A SharedPtr is a smart shared pointer to an instance of some class that implements reference counting |
| ion::base::SharedPtr< AllocationTracker > | |
| ion::base::SharedPtr< Allocator > | |
| ion::base::SharedPtr< InternalAllocator > | |
| ion::base::SharedPtr< ion::base::Shareable > | |
| ion::base::SharedPtr< SettingData > | |
| ion::base::logging_internal::SingleLogger | This class prints a message only the first time it is created for the passed file_name and line_number |
| ion::gfx::BufferObject::Spec | |
| ion::gfx::ShaderInputRegistry::Spec< T > | This struct is stored for each registered ShaderInput |
| ion::base::SpinMutex | SpinMutex exposes the same interface as ion::port::Mutex, but implements locking via a simple atomic CAS |
| ion::port::StackTrace | StackTrace acquires a stack trace for the current thread (not suitable for calling in an interrupt handler) on construction and supports conversion of raw stack pointers to a string of symbolic function names |
| ion::base::StaticDeleterBase | |
| ion::base::StaticDeleter< T > | This class should not be used directly |
| ion::base::StaticDeleter< T[]> | Specialization for arrays |
| ion::math::VectorBase< Dimension, T >::StaticHelper< Dim, U > | Helper struct to aid in Zero, Fill, and Axis functions |
| ion::math::VectorBase< Dimension, T >::StaticHelper< 1, U > | Specializations to help with static functions |
| ion::math::VectorBase< Dimension, T >::StaticHelper< 2, U > | |
| ion::math::VectorBase< Dimension, T >::StaticHelper< 3, U > | |
| ion::math::VectorBase< Dimension, T >::StaticHelper< 4, U > | |
| ion::gfx::TextureBase::SubImage | Wrapper around a sub-image, which is defined as an image, the xy offset of where it should be placed in the texture, and a mipmap level |
| T | |
| ion::gfx::ArrayInfo< T > | The below structs correspond to OpenGL "objects." For example, a BufferObject corresponds to an OpenGL buffer object, and a ProgramObject corresponds to an OpenGL program object |
| ion::gfx::BufferInfo< T > | A BufferInfo corresponds to an OpenGL Buffer Object |
| ion::gfx::FramebufferInfo< T > | A BufferInfo corresponds to an OpenGL Framebuffer Object |
| ion::gfx::ProgramInfo< T > | A ProgramInfo corresponds to an OpenGL Program Object |
| ion::gfx::RenderbufferInfo< T > | A RenderbufferInfo corresponds to an OpenGL Renderbuffer Object |
| ion::gfx::SamplerInfo< T > | A SamplerInfo corresponds to an OpenGL Sampler Object |
| ion::gfx::ShaderInfo< T > | A ShaderInfo corresponds to an OpenGL Shader Object |
| ion::gfx::SyncInfo< T > | A SyncInfo corresponds to an OpenGL Sync Object |
| ion::gfx::TextureInfo< T > | A TextureInfo corresponds to an OpenGL Texture Object |
| ion::gfx::TimerInfo< T > | A TimerInfo corresponds to an OpenGL Timer Query Object |
| ion::gfx::TransformFeedbackInfo< T > | A TransformFeedbackInfo corresponds to an OpenGL TransformFeedback Object |
| ion::text::TextSize | TextSize contains information about the size of multi-line text |
| ion::gfx::ResourceManager::TextureImageInfo | Struct containing information about a texture and its image(s) |
| ion::base::ThreadLocalObject< T > | This templated class makes it easy to create an instance of an object in thread-local storage |
| ion::base::ThreadLocalObject< ion::profile::TraceRecorder * > | |
| ion::base::ThreadLocalObject< NamedTraceRecorderArray > | |
| ion::base::ThreadSpawner | A ThreadSpawner instance launches a new thread in its constructor and waits for the thread to finish in its destructor |
| ion::base::logging_internal::ThrottledLogger | This class prints a message only if the passed file_name and line_number has not printed a message in a certain amount of time |
| Timeline | Copyright 2016 Google Inc |
| ion::profile::TimelineMetric | A timeline metric processes a timeline, computes a set of metrics and adds them to a Benchmark object |
| TimelineNode | Copyright 2016 Google Inc |
| TimelineEvent | Copyright 2016 Google Inc |
| TimelineFrame | Copyright 2016 Google Inc |
| TimelineRange | Copyright 2016 Google Inc |
| TimelineScope | Copyright 2016 Google Inc |
| TimelineThread | Copyright 2016 Google Inc |
| TimelineSearch | Search all nodes in a timeline that match a predicate |
| ion::port::Timer | |
| ion::gfx::TraceCallExtractor | Parses an OpenGL trace output generated by a GraphicsManager, segmenting it into a vector of calls with arguments |
| ion::profile::TraceRecorder::TraceHeader | |
| ion::port::android::Tracer | |
| ion::gfx::TracingHelper | This internal class is used by the GraphicsManager to print argument values when tracing OpenGL calls |
| ion::base::internal_variant_utils::TrueType | |
| ion::base::internal_variant_utils::is_emptytype< EmptyType< N > > | |
| ion::gfx::ProgramInfo< T >::Uniform | A uniform variable to a shader stage |
| ion::gfx::UniformHolder | A UniformHolder is a base class for an object that holds Uniforms |
| ion::gfx::Node | A Node instance represents a node in a scene graph |
| ion::gfx::UniformBlock | A UniformBlock is a grouping of uniforms that can be easily shared between multiple Nodes; changing a Uniform in a UniformBlock will thus automatically change it for all Nodes that share the block |
| std::unordered_map< K, T > | STL class |
| ion::base::AllocUnorderedMap< const ShaderInputRegistry::AttributeSpec *, GLint > | |
| ion::base::AllocUnorderedMap< const void *, uint32 > | |
| ion::base::AllocUnorderedMap< TextureResource *, GLuint > | |
| ion::base::AllocUnorderedMap< uint32, const char * > | |
| ion::base::AllocUnorderedMap< Key, Value, Hash, Pred > | This class can be used in place of std::unordered_map to allow an Ion Allocator to be used for memory allocation |
| std::unordered_set< K > | STL class |
| ion::base::AllocUnorderedSet< Value, Hash, Pred > | This class can be used in place of std::unordered_set to allow an Ion Allocator to be used for memory allocation |
| ion::remote::HttpClient::Url | Simple wrapper around a URL |
| ion::base::Utf8Iterator | Iterates over characters in strings encoded with UTF-8, extracting the Unicode index for each character |
| ion::analytics::Benchmark::VariableAccumulator | This class aids in accumulation of a benchmarked AccumulatedVariable |
| ion::analytics::Benchmark::VariableSampler | This class aids in creation of a benchmarked SampledVariable |
| ion::base::Variant< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40 > | The Variant class is similar to boost::variant |
| ion::base::Variant< GLint, GLfloat, math::Range1f, math::Range1i, GraphicsManager::ShaderPrecision, std::vector< GLint > > | |
| ion::base::Variant< int, uint32, float, math::VectorBase2f, math::VectorBase3f, math::VectorBase4f, math::VectorBase2i, math::VectorBase3i, math::VectorBase4i, math::VectorBase2ui, math::VectorBase3ui, math::VectorBase4ui, math::Matrix2f, math::Matrix3f, math::Matrix4f > | |
| ion::base::VariantTypeResolver< VariantType, TypeToResolve > | The VariantTypeResolver struct allows users of the Variant class to determine which type defined by a particular Variant can be used to store a value of a particular type |
| ion::gfx::ProgramInfo< T >::Varying | A varying to a fragment shader |
| std::vector< T > | STL class |
| ion::base::AllocVector< Allocation > | |
| ion::base::AllocVector< AtomicSizeT > | |
| ion::base::AllocVector< BufferAttributeInfo > | |
| ion::base::AllocVector< const Uniform * > | |
| ion::base::AllocVector< DeferredUpdate > | |
| ion::base::AllocVector< double > | |
| ion::base::AllocVector< Entry > | |
| ion::base::AllocVector< FunctionGroup > | |
| ion::base::AllocVector< GLuint > | |
| ion::base::AllocVector< ImageDataWrapper > | |
| ion::base::AllocVector< ImageUnit > | |
| ion::base::AllocVector< Index > | |
| ion::base::AllocVector< int > | |
| ion::base::AllocVector< ion::base::SharedPtr > | |
| ion::base::AllocVector< ion::gfx::Attribute > | |
| ion::base::AllocVector< ion::gfx::BufferObject::BufferSubData > | |
| ion::base::AllocVector< ion::gfx::BufferObject::Spec > | |
| ion::base::AllocVector< ion::gfx::ResourceHolder::FieldBase * > | |
| ion::base::AllocVector< ion::gfx::TextureBase::ion::gfx::TextureBase::SubImage > | |
| ion::base::AllocVector< ion::gfx::Uniform > | |
| ion::base::AllocVector< NotifierPtr > | |
| ion::base::AllocVector< Resource * > | |
| ion::base::AllocVector< StateTablePtr > | |
| ion::base::AllocVector< std::unique_ptr< ion::base::FunctionCallBase > > | |
| ion::base::AllocVector< std::unique_ptr< UniformStack > > | |
| ion::base::AllocVector< TraceRecorder * > | |
| ion::base::AllocVector< uint32 > | |
| ion::base::AllocVector< uint8 > | |
| ion::base::AllocVector< UniformCacheEntry > | |
| ion::base::AllocVector< VertexRange > | |
| ion::base::AllocVector< WrapperBase * > | |
| ion::base::InlinedAllocVector< ion::base::AllocUnorderedMap, 1 > | |
| ion::base::AllocVector< T > | This class can be used in place of std::vector to allow an Ion Allocator to be used for memory allocation |
| ion::base::InlinedAllocVector< T, N > | InlinedAllocVectoris a similar to AllocVector, but uses inlined storage for its first N elements, then uses an Ion Allocator if that size is exceeded |
| ion::math::VectorBase< Dimension, T > | VectorBase |
| ion::math::Point< Dimension, T > | Point |
| ion::math::Vector< Dimension, T > | Vector |
| ion::math::Vector< 4, T > | |
| ion::portgfx::Visual | Opaque class that sets up an offscreen OpenGL context/surface/visual in a platform-specific way to allow OpenGL calls to succeed on the current thread |
| ion::profile::VSyncProfiler | Singleton class that augments CallTraceManager with VSync tracing support |
| ion::base::WeakReferentPtr< T > | A WeakReferentPtr is a weak reference to an instance of some class derived from Referent |
| ion::base::WeakReferentPtr< FramebufferObject > | |
| ion::base::WorkerPool::Worker | Interface to enable pluggable worker behavior |
| ion::base::WriteLock | A WriteLock obtains a write lock, but has a similar interface to a Mutex and can be used with a WriteGuard |
| ion::base::ZipAssetManager | ZipAssetManager manages all zipfile assets in Ion |
| AttributeType | |
| bool | |
| Key | |
| size_t | |
| uint64 | |
| UniformType | |
| V | |
| Value | |
1.8.6 
