  base | |
  SettingManager | |
  SettingData | |
| gfx | |
 Renderer | |
 Resource | |
| ResourceBinder | |
| ResourceManager | |
| ShaderInputRegistryResource | |
| ShaderProgramResource | |
| VertexArrayResource | |
| ShaderInputRegistry | |
| gfxutils | |
| ShaderManager | |
| ShaderManagerData | |
| ion | Copyright 2016 Google Inc |
| analytics | |
 Benchmark | Types and utilities to make it easier to create performance benchmarks |
| AccumulatedVariable | This struct represents accumulated values for a variable |
| Constant | This struct represents a number that is constant over all samples |
| Descriptor | This struct stores information about a measurement computed by benchmarking |
| Sample | This struct represents a single timestamped value of a variable |
| SampledVariable | This struct represents a variable: a number that may vary over samples, such as a count or timing |
| VariableAccumulator | This class aids in accumulation of a benchmarked AccumulatedVariable |
| VariableSampler | This class aids in creation of a benchmarked SampledVariable |
| SampleMapping | Helper class for transforming samples between the time domain and the (unitless) normalized domain used for discrepancy calculation |
| IntervalDiscrepancy | Result of a discrepancy computation, including the value measured and the bounds of the interval where that value was measured |
| GpuPerformanceTester | GPUPerformanceTester measures basic GPU rendering characteristics |
| Measurement | |
| base | EnumHelper instantiations. These must be in the ion::base namespace |
| AllocTracker | |
| internal | |
| IsSameOrDerivedFrom | Helper structs |
| ResolverHelper | This struct is specialized for each of the defined types supported by a Variant |
| internal_variant_utils | |
| EmptyType | Taken from util/gtl/emptytype.h |
| TrueType | |
| FalseType | |
| is_emptytype | |
| is_emptytype< EmptyType< N > > | |
| ManualConstructor | Simplification of util/gtl/manual_constructor.h |
| logging_internal | Internal logging implementation |
| Logger | This class is used for regular logging |
| NullLogger | This class is used to disable logging, while still allowing for log messages to contain '<<' expressions |
| SingleLogger | This class prints a message only the first time it is created for the passed file_name and line_number |
| 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 |
| Allocatable | Allocatable is an abstract base class for classes whose memory is managed by an Allocator |
| AllocationManager | AllocationManager is a singleton class that is used to manage Allocators used to allocate Ion objects |
| AllocationSizeTracker | AllocationSizeTracker is an abstract base class for objects that track memory |
| AllocationTracker | AllocationTracker is an abstract base class for objects that track memory |
| Allocator | Allocator is an abstract base class for a memory allocator used for Ion objects derived from Allocatable |
| Array2 | Simple rectangular 2D array class with range-checked indexing, templatized by the element type |
| CallList | CallList contains a list of function calls to execute |
| CircularBuffer | Simple circular buffer class that has fixed capacity and does not grow automatically |
| DataContainer | Encapsulates arbitrary user data passed to Ion |
| DateTime | DateTime represents a particular date and time down to the nanosecond level along with timezone information |
| Range | A class to contain a beginning and ending DateTime |
| EnumHelper | }; static const char* kStrings[] = { "Value1", "Value2", "Value3" }; return EnumData<Values>(IndexMap<Values, uint32>(kValues, 3), kStrings); } |
| 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 |
| FunctionCallBase | FunctionCallBase does nothing but define a virtual operator() to allow containers of arbitrary FunctionCall<>s |
| FunctionCall | FunctionCall wraps an arbitrary call to a function, including its arguments |
| FunctionCall< ReturnType(Types...)> | Specialize for an arbitrary function signature |
| IndexMap | This template class can be used to map between two kinds of indices when the following assumptions apply: |
| GenericLockGuardBase | This file contains utility classes for automatically locking and unlocking mutexes |
| GenericLockGuard | A LockGuard locks a mutex when created, and unlocks it when destroyed |
| GenericTryLockGuard | A TryLockGuard attempts to lock a mutex when created, and if successful, will unlock it when destroyed |
| GenericUnlockGuard | An UnlockGuard is the reverse of a LockGuard; it unlocks a mutex when created and locks it when destroyed |
| ManualLockGuard | A ManualLockGuard can be used to protect a variable with a mutex in situations where it is not possible for scoping to be used |
| LogChecker | Can be used inside unit tests to trap all log output and verify that it matches what is expected |
| MemoryZipStream | A MemoryZipStream represents ZIP data in memory; the data may represent one or more files or directories in ZIP format |
| Notifier | A Notifier both sends notifications to and receives notifications from other Notifiers |
| NullLogEntryWriter | A NullLogEntryWriter can be used completely disable all logging programmatically as long as it exists |
| OnceFlag | OnceFlag ensures that a target function is only evaluated once |
| Lazy | Lazily populates a value |
| 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 |
| ReadLock | A ReadLock obtains a read lock, but has a similar interface to a Mutex and can be used with a ReadGuard |
| WriteLock | A WriteLock obtains a write lock, but has a similar interface to a Mutex and can be used with a WriteGuard |
| Referent | Thread-safe abstract base class |
| ReferentPtr | A ReferentPtr is a smart shared pointer to an instance of some class derived from Referent |
| ScopedAllocation | 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 |
| SettingBase | Base class for Setting, which encapsulates the name of the setting and any functors that should be called via NotifyListeners() |
| ListenerInfo | |
| SettingGroup | A SettingGroup is a convenience class to hold Settings that are in the same hierarchical group |
| Setting | Forward references |
| Setting< std::atomic< T > > | Specialize for std::atomic types |
| EnvironmentSetting | An EnvironmentSetting is a Setting can take its initial value from the named system environment variable passed to its constructor |
| ScopedSettingValue | Sets a Setting<T> to a new value |
| 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 |
| Shareable | Shareable is an abstract base class for any object that can be shared via the SharedPtr class |
| SharedPtr | A SharedPtr is a smart shared pointer to an instance of some class that implements reference counting |
| SpinMutex | SpinMutex exposes the same interface as ion::port::Mutex, but implements locking via a simple atomic CAS |
| StaticDeleterBase | |
| StaticDeleter | This class should not be used directly |
| StaticDeleter< T[]> | Specialization for arrays |
| StaticDeleterDeleter | StaticDeleterDeleter is an internal class that holds and deletes StaticDeleters; it should not be used directly |
| AllocDeque | This class can be used in place of std::deque to allow an Ion Allocator to be used for memory allocation |
| AllocMap | This class can be used in place of std::map to allow an Ion Allocator to be used for memory allocation |
| AllocSet | This class can be used in place of std::set to allow an Ion Allocator to be used for memory allocation |
| AllocUnorderedMap | This class can be used in place of std::unordered_map to allow an Ion Allocator to be used for memory allocation |
| AllocUnorderedSet | This class can be used in place of std::unordered_set to allow an Ion Allocator to be used for memory allocation |
| AllocVector | This class can be used in place of std::vector to allow an Ion Allocator to be used for memory allocation |
| InlinedAllocVector | InlinedAllocVectoris a similar to AllocVector, but uses inlined storage for its first N elements, then uses an Ion Allocator if that size is exceeded |
| StlAllocator | StlAllocator is derived std::allocator class that allows an Ion Allocator to be used for STL containers |
| rebind | |
| StlInlinedAllocator | 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 |
| rebind | |
| RebindHelper | Windows uses transient proxy allocators |
| RebindHelper< U, U > | Specialize for when the types are the same, that is, for the primary T allocator |
| ThreadLocalObject | This templated class makes it easy to create an instance of an object in thread-local storage |
| ThreadSpawner | A ThreadSpawner instance launches a new thread in its constructor and waits for the thread to finish in its destructor |
| BoolType | BoolType is a struct whose value member is either true or false |
| IsSameType | IsSameType is similar to std::is_same |
| IsSameType< T, T > | |
| IsBaseOf | IsBaseOf is similar to std::is_base_of |
| Helper | Because the Derived type-cast operator is non-const, it is preferred over the Base operator when calling Test() below |
| IsConvertible | IsConvertible is similar to std::is_convertible, except that it only looks at direct inheritance relationships (e.g |
| ConditionalType | ConditionalType is similar to std::conditional |
| ConditionalType< false, A, B > | |
| HasTrivialDestructor | HasTrivialDestructor is similar to std::has_trivial_destructor or std::is_trivially_destructible |
| Utf8Iterator | Iterates over characters in strings encoded with UTF-8, extracting the Unicode index for each character |
| Variant | The Variant class is similar to boost::variant |
| 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 |
| VariantTypeResolver | 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 |
| VectorDataContainer | VectorDataContainer is a special kind of DataContainer that is backed by an AllocVector |
| WeakReferent | Abstract base class that inherits from Referent, and adds the ability for instances to be referenced by a WeakReferentPtr |
| WeakReferentPtr | A WeakReferentPtr is a weak reference to an instance of some class derived from Referent |
| WorkerPool | Manages one or more threads that run in a loop, performing some work with each iteration (if any work is available) |
| Worker | Interface to enable pluggable worker behavior |
| ZipAssetManager | ZipAssetManager manages all zipfile assets in Ion |
| gfx | |
| Attribute | |
| AttributeArray | An AttributeArray represents a collection of Attributes used to describe the vertices of a Shape |
| 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 |
| BufferSubData | Specifies a destination byte range, read byte offset, and source BufferObject or DataContainer for BufferSubData and CopyBufferSubData |
| Spec | |
| BufferObjectElement | Structure for clients to use to encapsulate Elements |
| CubeMapTexture | A CubeMapTexture object represents the image data and mipmaps associated with the six faces of a cube map |
| FramebufferObject | A FramebufferObject describes an off-screen framebuffer that can be drawn to and read from like a regular framebuffer |
| Attachment | An attachment represents a data store attached to one of the framebuffer's targets |
| GraphicsManager | GraphicsManager manages the graphics library for an application |
| GlVersions | Simple wrapper for a set of GL versions |
| ShaderPrecision | Information about shader precision, see below |
| Image | An Image represents 2D image data that can be used in a texture supplied to a shader |
| PixelFormat | Struct representing the GL types for a particular Format (see above) |
| IndexBuffer | An IndexBuffer is a type of BufferObject that contains the element indices of an array, e.g., a vertex index array |
| Node | A Node instance represents a node in a scene graph |
| ArrayInfo | 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 |
| Attribute | |
| BufferInfo | A BufferInfo corresponds to an OpenGL Buffer Object |
| FramebufferInfo | A BufferInfo corresponds to an OpenGL Framebuffer Object |
| Attachment | |
| ProgramInfo | A ProgramInfo corresponds to an OpenGL Program Object |
| Attribute | An attribute to a vertex shader |
| Uniform | A uniform variable to a shader stage |
| Varying | A varying to a fragment shader |
| RenderbufferInfo | A RenderbufferInfo corresponds to an OpenGL Renderbuffer Object |
| SamplerInfo | A SamplerInfo corresponds to an OpenGL Sampler Object |
| ShaderInfo | A ShaderInfo corresponds to an OpenGL Shader Object |
| SyncInfo | A SyncInfo corresponds to an OpenGL Sync Object |
| TransformFeedbackInfo | A TransformFeedbackInfo corresponds to an OpenGL TransformFeedback Object |
| TextureInfo | A TextureInfo corresponds to an OpenGL Texture Object |
| TimerInfo | A TimerInfo corresponds to an OpenGL Timer Query Object |
| Renderer | Handles rendering ION scene graphs using OpenGL |
| ResourceBase | ResourceBase is an internal abstract base class for managed resources |
| 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 |
| Field | A generic field that represents some state in the resource |
| FieldBase | Base class for Fields (see below) |
| RangedField | A Field that has a limited valid range of values |
| VectorField | A Field that holds a vector of up to some number of values |
| ResourceManager | A ResourceManager is an interface for getting information about a Renderer's internal resources |
| ArrayResourceInfo | The below info types contain additional informative fields about resources |
| BufferTargetInfo | |
| DataRequest | Wrapper struct for data requests |
| FramebufferResourceInfo | |
| InfoCallback | Callbacks called when requested resource information is available |
| PlatformInfo | Struct for getting information about the local OpenGL platform |
| ResourceInfo | Resource info types |
| ResourceRequest | Wrapper struct for resource info requests |
| TextureImageInfo | Struct containing information about a texture and its image(s) |
| TextureResourceInfo | |
| Sampler | A Sampler object represents texture parameters that control how texture data is accessed in shaders |
| ShaderBase | Base class for Shader and ShaderProgram objects |
| Shader | A Shader represents an OpenGL shader stage |
| ShaderInputBase | |
| ShaderInput | A ShaderInput instance represents a general shader input |
| ShaderInputRegistry | A ShaderInputRegistry is used to manage a collection of shader inputs to a specific ShaderProgram (both uniforms and attributes) |
| CombineFunction | This type defines a function that is used to combine values for two instances of a registered shader input |
| GenerateFunction | A GenerateFunction is similar to a CombineFunction, above, but generates additional inputs based on the value of a single input |
| Spec | This struct is stored for each registered ShaderInput |
| ShaderProgram | A ShaderProgram represents an OpenGL shader program that can be applied to shapes |
| Shape | A Shape object represents a shape (vertices + indices) to draw |
| StateTable | A StateTable represents a collection of graphical state items that affect OpenGL rendering |
| TextureBase | This is an internal base class for all texture types |
| Face | Internal class that wraps texture data: a single image or a stack of mipmaps, and any sub- or layered data |
| 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 |
| Texture | A Texture object represents the image data and mipmaps associated with a single texture |
| TextureManager | TextureManager is an internal Ion class, and is not exported for public use |
| TraceCallExtractor | Parses an OpenGL trace output generated by a GraphicsManager, segmenting it into a vector of calls with arguments |
| TracingHelper | This internal class is used by the GraphicsManager to print argument values when tracing OpenGL calls |
| Uniform | A Uniform instance represents a uniform shader argument |
| 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 |
| UniformHolder | A UniformHolder is a base class for an object that holds Uniforms |
| gfxprofile | |
| GpuProfiler | Singleton class that augments CallTraceManager with GPU tracing support |
| ScopedGlTracer | Traces the GPU start and end times of the GL commands submitted in the same scope |
| gfxutils | |
| BufferToAttributeBinder | 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 |
| Frame | Frame manages an application-defined frame of execution |
| Printer | Can be used for debugging |
| ResourceCallback | Class that allows blocking until a callback is called and automagically destroys itself after both Callback() and WaitForCompletion() have executed |
| ShaderManager | ShaderManager contains an association between shader programs, their names, and any source dependencies they have |
| ShaderSourceComposer | A ShaderSourceComposer is a generic interface for constructing a shader source string |
| StringComposer | Simple composer that just returns the string passed to its constructor |
| FilterComposer | Applies a fixed transformation to the output of another composer |
| IncludeComposer | Loads a shader source from a resource that may include other resources using the special directive '$input "name"' |
| ZipAssetComposer | Loads a shader source from zip asset resources that may $input other zip assets |
| ShapeSpec | This struct contains specifications common to all basic shapes |
| ExternalShapeSpec | External geometry formats |
| PlanarShapeSpec | Planar shape |
| RectangleSpec | Rectangle |
| RegularPolygonSpec | Regular polygon |
| BoxSpec | Box |
| EllipsoidSpec | Ellipsoid |
| CylinderSpec | Cylinder |
| image | |
| NinePatch | Represents a nine-patch image as described in the Android SDK reference |
| math | |
| internal | Internal helper functions |
| Angle | A simple class to represent angles |
| FieldOfView | Encapsulates a generalized, asymmetric field of view with four half angles |
| Matrix | The Matrix class defines a square N-dimensional matrix |
| Range1TWrapper | 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 |
| RangeBase | The RangeBase class makes it possible to treat Ranges with Dimension=1 specially |
| RangeBase< 1, T > | Specialize for Dimension=1 |
| Range | The Range class defines an N-dimensional interval defined by minimum and maximum N-dimensional endpoints |
| Rotation | The Rotation class represents a rotation around a 3-dimensional axis |
| VectorBase | VectorBase |
| StaticHelper | Helper struct to aid in Zero, Fill, and Axis functions |
| StaticHelper< 1, U > | Specializations to help with static functions |
| StaticHelper< 2, U > | |
| StaticHelper< 3, U > | |
| StaticHelper< 4, U > | |
| Vector | Vector |
| Point | Point |
| port | |
| android | |
| LocalFrame | Pushes and pops a JNI local reference frame |
| ScopedJObject | Stack-allocate this to clean up a jobject at end of scope |
| Tracer | |
| ScopedTrace | |
| Barrier | Defines a multi-thread barrier that allows N threads to synchronize execution |
| LogEntryWriter | Abstract class which can be overridden to integrate Ion logging with other logging systems |
| MemoryMappedFile | Read-only in-memory view of an entire file on disk |
| Mutex | A Mutex is used to ensure that only one thread or process can access a block of code at one time |
| Semaphore | A Semaphore enables threads and process synchronization |
| 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 |
| Timer | |
| 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 |
| profile | |
| CallTraceManager | Manages call trace recording for visualization in Web Tracing Framework (WTF) format |
| ScopedTracer | Class to automatically record scope start and end events using the given TraceRecorder |
| ScopedFrameTracer | Class to automatically record frame start and end events using the given TraceRecorder |
| TimelineMetric | A timeline metric processes a timeline, computes a set of metrics and adds them to a Benchmark object |
| TraceRecorder | Class for recording frame events |
| TraceHeader | |
| VSyncProfiler | Singleton class that augments CallTraceManager with VSync tracing support |
| remote | |
| CallTraceHandler | CallTraceHandler serves a snapshot of the current call trace |
| HttpClient | HttpClient is a very basic class that sends HTTP requests and returns the server's response |
| Response | |
| Url | Simple wrapper around a URL |
| HttpServer | |
| RequestHandler | RequestHandlers handle requests for a file or path |
| Websocket | Represents the server side of a connected Websocket |
| NodeGraphHandler | NodeGraphHandler serves files to display Ion node graphs as text or HTML using the gfxutils::Printer class |
| RemoteServer | A RemoteServer starts an HttpServer with a predefined handler for the /ion subdirectory |
| ResourceHandler | ResourceHandler serves files related to OpenGL resources |
| SettingHandler | SettingHandler serves files related to Settings, including an interface for viewing and modifying them |
| ShaderHandler | ShaderHandler serves files related to shaders, their dependencies, and the shader editor |
| TracingHandler | TracingHandler serves files related to OpenGL tracing |
| text | |
| BasicBuilder | BasicBuilder is a derived Builder class that uses a very basic shader to render 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 |
| Rectangle | Structure representing a rectangle to pack into the bin |
| Builder | Builder is an abstract base class for building graphics objects used to render text |
| CoreTextFont | This represents a single CoreText font |
| Font | Font is a base class for implementation-specific representations of fonts |
| FontMetrics | This struct represents the cumulative metrics for the font |
| GlyphGrid | A grid representing a rendered glyph, with each grid pixel representing pixel coverage in the range (0,1) |
| FontImage | A FontImage contains image and texture coordinate information used to render font glyphs |
| ImageData | Data for each image in the FontImage |
| StaticFontImage | StaticFontImage is a derived FontImage that contains a single ImageData instance that is created by the constructor and that cannot be modified afterward |
| DynamicFontImage | DynamicFontImage is a derived FontImage that may contain any number of ImageData instances |
| FontManager | The FontManager provides the main interface for fonts used to create text strings to render |
| FreeTypeFont | This derived Font class represents a FreeType2 font |
| GlyphMetrics | This struct represents the metrics for a single glyph |
| TextSize | TextSize contains information about the size of multi-line text |
| FreeTypeFontTransformData | This contains the values needed to transform glyph rectangles into the correct coordinates |
| LayoutOptions | This struct defines parameters affecting layout of a single text string when passed to BuildLayout() |
| Layout | A Layout instance specifies how glyphs are arranged to form text |
| Glyph | A Glyph represents one character glyph in the layout |
| Quad | A Quad represents a 3D quadrilateral onto which a character glyph in the layout will be drawn |
| OutlineBuilder | OutlineBuilder is a derived Builder class that can render text with outlines |
| pp | Copyright 2016 Google Inc |
| Sequence | |
| T | |
| Timeline | Copyright 2016 Google Inc |
| const_iterator | Traverses the hierarchy in pre-order |
| TimelineEvent | Copyright 2016 Google Inc |
| TimelineFrame | Copyright 2016 Google Inc |
| TimelineNode | Copyright 2016 Google Inc |
| TimelineRange | Copyright 2016 Google Inc |
| TimelineScope | Copyright 2016 Google Inc |
| TimelineSearch | Search all nodes in a timeline that match a predicate |
| const_iterator | |
| TimelineThread | Copyright 2016 Google Inc |
1.8.6 
