| _k3d::mesh_modifier< base_t > | |
| ActiveRegion | |
| benchmarking::benchmarkMesh | |
| benchmarking::k3dProfilingProcessor | |
| benchmarking::ResultSet | |
| benchmarking::ResultsProcessor | |
| big_integer | |
| boost::gil::channel_traits< half > | |
| break_cycles | |
| CachedVertex | |
| cloth_solver | |
| colored_light | |
| CompareArgs | |
| cuda_device_mesh | Start fleshing out cuda mesh structure |
| cuda_device_polyhedra | |
| d_Math::d_Vec3f | |
| d_Math::d_Vecf | |
| detail::glu_triangulator_t< OutputFaceIterator, OutputPointIterator > | |
| Dict | |
| DictNode | |
| EdgePair | |
| extract_alpha | |
| extract_rgb | |
| FaceCount | |
| FunctionParser | |
| FunctionParser::Data | |
| FunctionParser::Data::FuncPtrData | |
| FUNCTIONPARSERTYPES::FuncDefinition | |
| glew_context | |
| GLUface | |
| GLUhalfEdge | |
| GLUmesh | |
| GLUvertex | |
| Inotify | Inotify class |
| InotifyEvent | Inotify event class |
| InotifyException | Class for inotify exceptions |
| InotifyWatch | Inotify watch class |
| k3d::angle_axis | Encapsulates an angle/axis representation of an object's orientation |
| k3d::application_implementation | Provides an implementation of k3d::iapplication for use by embedders |
| k3d::application_implementation::implementation | Encapsulates the running K-3D server application |
| k3d::application_plugin_factory< plugin_t, interface_list > | |
| k3d::array | |
| k3d::aspect_ratio | Encapsulates a named aspect ratio |
| k3d::basic_alpha< SampleType, SampleTraits > | Encapsulates storage for an alpha color sample |
| k3d::basic_hsv | Encapsulates storage for an HSV color sample |
| k3d::basic_luma< SampleType, SampleTraits > | Encapsulates storage for a luma color sample |
| k3d::basic_luma_alpha< SampleType, SampleTraits > | Encapsulates storage for a luma color sample with alpha |
| k3d::basic_rgb< SampleType, SampleTraits > | Encapsulates storage for an RGB color sample |
| k3d::basic_rgba< SampleType, SampleTraits > | Encapsulates storage for an RGBA color sample |
| k3d::bezier_triangle_patch::const_primitive | Gathers the member arrays of a bezier_triangle_patch primitive into a convenient package |
| k3d::bezier_triangle_patch::primitive | Gathers the member arrays of a bezier_triangle_patch primitive into a convenient package |
| k3d::bicubic_patch::const_primitive | Gathers the member arrays of a bicubic_patch primitive into a convenient package |
| k3d::bicubic_patch::primitive | Gathers the member arrays of a bicubic_patch primitive into a convenient package |
| k3d::bilinear_patch::const_primitive | Gathers the member arrays of a bilinear_patch primitive into a convenient package |
| k3d::bilinear_patch::primitive | Gathers the member arrays of a bilinear_patch primitive into a convenient package |
| k3d::bitmap_modifier< derived_t > | |
| k3d::bitmap_sink< derived_t > | |
| k3d::bitmap_source< derived_t > | Boilerplate CRTP class for bitmap source objects that produce a k3d::bitmap* as output |
| k3d::blobby::const_primitive | Gathers the member arrays of a blobby primitive into a convenient package |
| k3d::blobby::primitive | Gathers the member arrays of a blobby primitive into a convenient package |
| k3d::bounding_box3 | Stores an axis-aligned bounding-box in three space |
| k3d::color_source< derived_t > | |
| k3d::color_traits< SampleType > | Describes traits of a type used as a sample within a color specification |
| k3d::color_traits< boost::uint16_t > | Specialization of color_traits for 16 bit samples |
| k3d::color_traits< boost::uint8_t > | Specialization of color_traits for 8 bit samples |
| k3d::color_traits< double_t > | Specialization of color_traits for double samples |
| k3d::color_traits< float > | Specialization of color_traits for float samples |
| k3d::color_traits< half > | Specialization of color_traits for half samples |
| k3d::cone::const_primitive | Gathers the member arrays of a cone primitive into a convenient package |
| k3d::cone::primitive | Gathers the member arrays of a cone primitive into a convenient package |
| k3d::contributor | |
| k3d::cubic_curve::const_primitive | Gathers the member arrays of a cubic_curve primitive into a convenient package |
| k3d::cubic_curve::primitive | Gathers the member arrays of a cubic_curve primitive into a convenient package |
| k3d::cuda_mesh_simple_deformation_modifier | Mesh modifier implementation for use in plugins that deform a mesh (modify its points) without altering topology, and based solely on the input point positions and selection. To create a plugin, derive from mesh_simple_deformation_modifier and implement the on_deform_mesh() method. If you are only modifying points but need more information about the input mesh, consider using mesh_deformation_modifier instead |
| k3d::cylinder::const_primitive | Gathers the member arrays of a cylinder primitive into a convenient package |
| k3d::cylinder::primitive | Gathers the member arrays of a cylinder primitive into a convenient package |
| k3d::data::array_serialization< value_t, property_policy_t > | Serialization policy for data containers that can be serialized as XML |
| k3d::data::change_signal< value_t > | Signal policy for data containers that notify observers when their value changes, including through undo/redo |
| k3d::data::composition_t< lhs_t, rhs_t > | Helper class used to consolidate two initializers into a single node |
| k3d::data::constraint::maximum_t< value_t > | Constraint node that enforces a maximum value (using the std::min concept) |
| k3d::data::constraint::minimum_t< value_t > | Constraint node that enforces a minimum value (using the std::max concept) |
| k3d::data::constraint_t< data_t > | Helper class used to initialize a data container's constraints |
| k3d::data::container< value_t, serialization_policy_t > | Host class for storing data using serialization, property, name, constraint, undo, storage, and signal policies |
| k3d::data::description_t | Helper class used to initialize a data container's description |
| k3d::data::enumeration_property< value_t, name_policy_t > | Property policy that exposes a data container as a K-3D enumeration property |
| k3d::data::enumeration_t | Helper class used to initialize enumeration property types |
| k3d::data::explicit_change_signal< value_t > | Signal policy for data containers that notify observers when their value changes. Observers can choose whether to be notified every time the value changes (including undo/redo), or only when the value is changed explicitly by a caller |
| k3d::data::external_owner_initializer_t | Helper class used to initialize data containers |
| k3d::data::iconstraint< value_t > | Abstract interface for a chain-of-responsibility constraint node |
| k3d::data::immutable_name< constraint_policy_t > | Name policy for data containers whose name cannot be changed |
| k3d::data::initializer_t< init_t > | Allows an arbitrary set of initializers to be consolidated into a single node |
| k3d::data::label_t | Helper class used to initialize a data container's label |
| k3d::data::list_property< value_t, name_policy_t > | Property policy that exposes a data container as a K-3D list property |
| k3d::data::local_storage< value_t, signal_policy_t > | Storage policy for data containers that store their state by value |
| k3d::data::local_storage< value_t, signal_policy_t >::value_container | Provides an implementation of istate_container for storing nodes by value (ValueType must have a copy constructor and assignment operator) |
| k3d::data::measurement_property< value_t, name_policy_t > | Property policy that exposes a data container as a K-3D measurement property |
| k3d::data::name_t | Helper class used to set a data container's name |
| k3d::data::no_constraint< value_t, undo_policy_t > | Constraint policy for data containers whose values are unconstrained |
| k3d::data::no_name< constraint_policy_t > | Name policy for unnamed data containers |
| k3d::data::no_property< value_t, name_policy_t > | Property policy for data containers that do not expose their values using the K-3D property mechanism |
| k3d::data::no_serialization< value_t, property_policy_t > | Serialization policy for data containers that do not need to be serialized |
| k3d::data::no_signal< value_t > | Signal policy for data containers that do not notify observers when their value changes |
| k3d::data::no_undo< value_t, storage_policy_t > | Undo policy for data containers that do not store state changes for undo/redo |
| k3d::data::node_collection_serialization< value_t, property_policy_t > | Serialization policy for data containers that can be serialized as XML |
| k3d::data::node_property< value_t, name_policy_t > | Property policy that exposes a data container as a K-3D node property |
| k3d::data::node_serialization< value_t, property_policy_t > | Serialization policy for data containers that store a document node and can be serialized as XML |
| k3d::data::node_storage< value_t, signal_policy_t > | Storage policy for data containers that store a pointer to a document node that could be deleted by the user at any time - note that value_t should be the interface type used to access the node |
| k3d::data::node_storage< value_t, signal_policy_t >::value_container | Provides an implementation of istate_container for storing nodes by value (ValueType must have a copy constructor and assignment operator) |
| k3d::data::owner_initializer_t< owner_t > | Helper class used to initialize data containers |
| k3d::data::path_mode_t | Helper class used to initialize the mode for path property nodes |
| k3d::data::path_property< value_t, name_policy_t > | Property policy that exposes a data container as a writable K-3D path property |
| k3d::data::path_serialization< value_t, property_policy_t > | Serialization policy for filesystem path data that handles external filesystem resources |
| k3d::data::path_type_t | Helper class used to initialize the type for path property nodes |
| k3d::data::pointer_demand_storage< pointer_t, signal_policy_t > | Read-only storage policy that stores a value by pointer, created on-demand |
| k3d::data::pointer_storage< pointer_t, signal_policy_t > | Read-only storage policy that stores a value by pointer, created on-demand |
| k3d::data::read_only_property< value_t, name_policy_t > | Property policy that exposes a data container as a read-only K-3D property |
| k3d::data::script_property< value_t, name_policy_t > | Property policy that exposes a data container as a writable K-3D script property |
| k3d::data::slot_initializer_t< slot_t > | Helper class used to initialize slots |
| k3d::data::step_increment_t | Helper class used to initialize measurement properties |
| k3d::data::string_property< value_t, name_policy_t > | Property policy that exposes a data container as a writable string property |
| k3d::data::units_t | Helper class used to initialize measurement properties |
| k3d::data::value_demand_storage< value_t, signal_policy_t > | Storage policy that computes a value on-demand |
| k3d::data::value_initializer_t< value_t > | Helper class used to set a data container's initial value |
| k3d::data::values_t< data_t > | Helper class used to initialize list properties |
| k3d::data::with_constraint< value_t, undo_policy_t > | Policy for data nodes whose values are constrained by a chain of one-to-many iconstraint nodes |
| k3d::data::with_serialization< value_t, property_policy_t > | Serialization policy for data containers that can be serialized as XML |
| k3d::data::with_undo< value_t, storage_policy_t > | Undo policy for data containers that stores state changes for undo/redo |
| k3d::data::writable_property< value_t, name_policy_t > | Property policy that exposes a data container as a writable K-3D property |
| k3d::delete_object | Use with std::for_each to destroy collections of objects stored by pointer |
| k3d::dependencies | |
| k3d::detail::application_plugin_factory_proxy | Proxies plugin factories so we can delay loading shared libraries at runtime until they're needed |
| k3d::detail::bezier_implementation< n, i, value_t, iterator_t > | |
| k3d::detail::bezier_implementation< n, 0, value_t, iterator_t > | |
| k3d::detail::delete_snap_object | |
| k3d::detail::document_implementation | This is a real abortion, but it solves our interdependency problems among state recorder, pipeline, and property collection implementations |
| k3d::detail::document_plugin_factory_proxy | Proxies plugin factories so we can delay loading shared libraries at runtime until they're needed |
| k3d::detail::factorial< n > | Compile-time computation of an integer factorial |
| k3d::detail::factorial< 0 > | |
| k3d::detail::factory_id_filter_t< functor_t > | |
| k3d::detail::find_companion_worker | |
| k3d::detail::instance_container< instance_t > | |
| k3d::detail::log_stream | |
| k3d::detail::log_stream_init | |
| k3d::detail::mark_used_primitive_points | Helper object used by lookup_unused_points() |
| k3d::detail::node_collection_implementation | |
| k3d::detail::node_collection_implementation::add_nodes_container | |
| k3d::detail::node_collection_implementation::remove_nodes_container | |
| k3d::detail::offset_point_indices | |
| k3d::detail::plugin_registry | Implements iplugin_registry, allowing modules to register new plugin factories, which are pushed into two collections - a set of all plugin factories, and a set of factories for the given module |
| k3d::detail::public_document_implementation | Encapsulates an open K-3D document |
| k3d::detail::remap_primitive_points | Helper object used by delete_points() |
| k3d::detail::same_factory_id | |
| k3d::detail::same_name | |
| k3d::detail::signal_buf | When attached to an output stream, emits a signal containing each line of output |
| k3d::detail::state_recorder_implementation | Provides a concrete implementation of istate_recorder |
| k3d::detail::type_info | "Wraps" a std::type_info object so it can be used as the key in a sorted container |
| k3d::difference::accumulator | Stores the results of the difference::test() function |
| k3d::disk::const_primitive | Gathers the member arrays of a disk primitive into a convenient package |
| k3d::disk::primitive | Gathers the member arrays of a disk primitive into a convenient package |
| k3d::document_plugin_factory< plugin_t, interface_list > | |
| k3d::double_source< derived_t > | |
| k3d::euler_angles | Encapsulates a set of Euler angles, including the order in which they should be applied |
| k3d::explicit_snap_source | |
| k3d::explicit_snap_target | |
| k3d::expression::basic_parser | Provides a parser that can execute functions with C-like syntax, returning a double result |
| k3d::expression::basic_parser::implementation | |
| k3d::expression::binary_operator_t< operator_t > | Applies a binary function to the top two values of the stack |
| k3d::expression::expression_grammar | Encapsulates a grammar for evaluating basic mathematics expressions |
| k3d::expression::expression_grammar::definition< ScannerT > | |
| k3d::expression::parser | Refinement of basic_parser that provides a standard set of functions and constants |
| k3d::expression::push_constant | Inserts a constant numeric value onto the stack |
| k3d::expression::push_number | Inserts a parsed numeric value onto the stack |
| k3d::expression::unary_operator_t< operator_t > | Applies a unary function to the top of the stack |
| k3d::file_range | Encapsulates a half-open range of numbered files (useful for working with animation frames) |
| k3d::filesystem::basic_fstream< charT, traits > | Convenience wrapper for standard fstream that opens a k3d::filesystem::path in binary mode |
| k3d::filesystem::basic_ifstream< charT, traits > | Convenience wrapper for standard fstream that opens a k3d::filesystem::path in binary mode |
| k3d::filesystem::basic_ofstream< charT, traits > | Convenience wrapper for standard fstream that opens a k3d::filesystem::path in binary mode |
| k3d::filesystem::directory_iterator | Provides iteration over the contents of a directory |
| k3d::filesystem::directory_iterator::implementation | |
| k3d::filesystem::gzstreambase | |
| k3d::filesystem::gzstreambuf | |
| k3d::filesystem::igzstream | Ifstream replacement that can read files with gzip compression |
| k3d::filesystem::ogzstream | Ofstream replacement that writes files with gzip compression |
| k3d::filesystem::path | Portable filesystem path that closely follows the boost::filesystem::path interface, with some important exceptions |
| k3d::filesystem::path::iterator | |
| k3d::filesystem::path::iterator::implementation | |
| k3d::frame | Encapsulates an animation frame (a range of time) to be rendered |
| k3d::geometry::point_selection::const_storage | Gathers the member arrays of a point selection into a convenient package |
| k3d::geometry::point_selection::storage | Gathers the member arrays of a mutable point selection into a convenient package |
| k3d::geometry::primitive_selection::const_storage | Gathers the member arrays of a primitive selection into a convenient package |
| k3d::geometry::primitive_selection::merge_primitive_selection | |
| k3d::geometry::primitive_selection::storage | Gathers the member arrays of a mutable primitive selection into a convenient package |
| k3d::get_interfaces< interface_list< head_t, tail_t > > | Generates code at compile-time that returns a list of interface types |
| k3d::get_interfaces< null_interface > | Generates code at compile-time that returns a list of interface types |
| k3d::gl::api | |
| k3d::gl::context | Abstract interface implemented by OpenGL context objects |
| k3d::gl::context_factory | Abstract interface implemented by objects that can create OpenGL render context objects, |
| k3d::gl::detail::redraw | |
| k3d::gl::ilight | Abstract interface for objects that act as a light source while drawing OpenGL graphics |
| k3d::gl::imesh_painter | Abstract interface implemented by painter objects that can render a mesh using OpenGL |
| k3d::gl::irender_viewport | Abstract interface for objects that can render using OpenGL |
| k3d::gl::irenderable | Abstract interface implemented by objects that can render themselves using the OpenGL API |
| k3d::gl::mesh_painter | Provides a boilerplate implementation of k3d::gl::imesh_painter |
| k3d::gl::offscreen_context | Abstract interface implemented by OpenGL context objects |
| k3d::gl::offscreen_context_factory | Abstract interface implemented by objects that can create OpenGL render context objects, |
| k3d::gl::painter_render_state | Used to pass rendering state from a node to a mesh painter |
| k3d::gl::painter_selection_state | Used to pass selection state from a node to a mesh painter |
| k3d::gl::render_state | Used to pass (potentially) useful rendering state from the engine to the object being rendered |
| k3d::gl::renderable< base_t > | Provides a boilerplate implementation of k3d::gl::irenderable |
| k3d::gl::selection_state | Used to pass selection-related state to OpenGL painters |
| k3d::gl::store_attributes | Provides exception- and return-safe RAII behavior for saving / restoring OpenGL attributes |
| k3d::graph::undirected | Encapsulates an undirected graph with arbitrary vertex and edge attributes |
| k3d::graph::undirected::edge | |
| k3d::graph::undirected::vertex | |
| k3d::graph_modifier | |
| k3d::graph_source | |
| k3d::hint::any | Used when creating a hint-mapping that matches any incoming hint type |
| k3d::hint::bitmap_dimensions_changed | Hint passed to downstream nodes to indicate that the pixel dimensions of a bitmap have changed (and thus its internal memory) |
| k3d::hint::bitmap_pixels_changed | Hint passed to downstream nodes to indicate that the pixel values of a bitmap have changed (i.e. one-or-more pixels have changed color) |
| k3d::hint::convert< SourceT, TargetT, NextT > | |
| k3d::hint::detail::converter< ListT > | |
| k3d::hint::file_changed | Hint object that indicates a file was changed |
| k3d::hint::graph_attributes_changed | Hint object that indicates that a graph's attributes have changed |
| k3d::hint::graph_topology_changed | Hint object that indicates that a graph's topology has changed |
| k3d::hint::hint_traits< HintT > | Hint traits template responsible for matching and converting hints |
| k3d::hint::hint_traits< any > | |
| k3d::hint::hint_traits< bitmap_dimensions_changed > | |
| k3d::hint::hint_traits< bitmap_pixels_changed > | |
| k3d::hint::hint_traits< graph_attributes_changed > | |
| k3d::hint::hint_traits< graph_topology_changed > | |
| k3d::hint::hint_traits< mesh_geometry_changed > | |
| k3d::hint::hint_traits< mesh_topology_changed > | |
| k3d::hint::hint_traits< none > | |
| k3d::hint::hint_traits< selection_changed > | |
| k3d::hint::hint_traits< unchanged > | |
| k3d::hint::last_conversion | |
| k3d::hint::mesh_deleted | Hint object that indicates a mesh was deleted |
| k3d::hint::mesh_geometry_changed | Hint object that indicates that a mesh's geometry (the locations of its points) has changed |
| k3d::hint::mesh_topology_changed | Hint object that indicates that a mesh's topology has changed |
| k3d::hint::none | Used when creating a hint-mapping that maps to a NULL ("none") hint |
| k3d::hint::print | Iostream-compatible manipulator object that serializes information about a hint object |
| k3d::hint::selection_changed | Hint object that indicates that an object's selection state has changed |
| k3d::hint::unchanged | Used when creating a hint-mapping that does not convert hints |
| k3d::hyperboloid::const_primitive | Gathers the member arrays of a hyperboloid primitive into a convenient package |
| k3d::hyperboloid::primitive | Gathers the member arrays of a hyperboloid primitive into a convenient package |
| k3d::i3d_2d_mapping | |
| k3d::iapplication | Abstract interface for the global K-3D Application object |
| k3d::iapplication_plugin_factory | Abstract factory interface for plugin objects |
| k3d::ibitmap_exporter | Abstract interface for objects capable of exporting bitmap images |
| k3d::ibitmap_importer | Abstract interface for objects capable of importing bitmaps from a filesystem |
| k3d::ibitmap_sink | Abstract interface for objects that can consume bitmap data |
| k3d::ibitmap_source | Abstract interface for objects that can act as a source of bitmapes |
| k3d::ibounded | Abstract interface for quickly determining the bounding box of objects that fill a 3D volume |
| k3d::icamera | Abstract interface for objects that can host (provide position and projection information to) a viewport |
| k3d::icolor_source | Abstract interface for objects that can act as a source of color values |
| k3d::icrop_window | Abstract interface for an object whose output can be cropped (units are in projection-space) |
| k3d::idependencies | Abstract interface that allows objects to register dependencies for serialization |
| k3d::idocument | Abstract interface for an open K-3D document |
| k3d::idocument_exporter | Abstract interface implemented by objects that can export data from a K-3D document |
| k3d::idocument_importer | Abstract interface for objects that can import data into an existing K-3D document |
| k3d::idocument_plugin_factory | Abstract factory interface for plugin objects |
| k3d::idocument_sink | Abstract interface for objects that can be optionally 'bound' to a specific document |
| k3d::idouble_source | Abstract interface for objects that can act as a source of k3d::double_t values |
| k3d::ienumeration_property | Abstract interface for discovering information about an enumerated property |
| k3d::ienumeration_property::enumeration_value_t | Stores information about an individual enumeration value |
| k3d::ievent_loop | Abstract interface for event loop (user interface) plugins |
| k3d::ifile_change_notifier | Interface implemented by objects that can signal changes to files |
| k3d::ihint | Abstract interface implemented by objects that can act as "hints" for change events |
| k3d::iint32_source | Abstract interface for objects that can act as a source of k3d::int32_t values |
| k3d::ikeyframer | Abstract interface for objects that set keyframes |
| k3d::ilist_property< data_t > | Abstract interface for discovering information about a list property (a property for which there is a set of predefined values, but other values are allowed) |
| k3d::imaterial | Abstract interface implemented by objects that can act as geometric surface materials |
| k3d::imaterial_sink | Abstract interface for objects that can "consume" an imaterial |
| k3d::imatrix_sink | Abstract interface for objects that can act as consumers of transformation data |
| k3d::imatrix_source | Abstract interface for objects that can act as a source of transformation data |
| k3d::imeasurement_property | Abstract interface for discovering information about a property that uses real-world units-of-measure |
| k3d::imesh_selection_algorithm | Abstract interface for objects that can create mesh selections |
| k3d::imesh_selection_sink | Abstract interface for objects that can consume mesh data |
| k3d::imesh_sink | Abstract interface for objects that can consume mesh data |
| k3d::imesh_source | Abstract interface for objects that can act as a source of meshes |
| k3d::imesh_storage | Abstract interface for objects that can provide persistent storage of meshes (the FrozenMesh object being the canonical example) |
| k3d::imeta_object | Abstract interface for objects that can accept commands from external entities |
| k3d::imetadata | Abstract interface for objects that can store arbitrary metadata (name-value pairs) |
| k3d::imime_type_handler | Abstract interface for objects that can identify the MIME Type of a file |
| k3d::implements_interface< interface_list< head_t, tail_t > > | Generates code at compile-time that test whether an interface_list contains a specific interface type |
| k3d::implements_interface< null_interface > | Generates code at compile-time that test whether an interface_list contains a specific interface type |
| k3d::imulti_mesh_sink | Abstract interface for objects that can consume multiple meshes |
| k3d::inetwork_render_farm | Abstract interface that encapsulates a "render farm" capable of executing render jobs |
| k3d::inetwork_render_frame | |
| k3d::inetwork_render_frame::argument | Defines storage for a command-line argument |
| k3d::inetwork_render_frame::variable | Defines storage for an environment variable |
| k3d::inetwork_render_job | Abstract interface encapsulating a render job containing zero-to-many frames to be rendered |
| k3d::inode | Abstract interface which MUST be implemented by ALL document nodes |
| k3d::inode_change_signal | Abstract interface for nodes that broadcast a change signal to observers when their state is modified |
| k3d::inode_collection | Abstract interface for a collection of document nodes |
| k3d::inode_collection_property | Provides domain-specific methods for a property that stores a collection of nodes as its value |
| k3d::inode_collection_sink | |
| k3d::inode_name_map | Abstract interface for a collection of document node names |
| k3d::inode_property | Abstract interface for discovering information about a property that references another node |
| k3d::inode_selection | Abstract interface for objects that store document node selections and their weights |
| k3d::inserter_t< container_t > | |
| k3d::int32_source< derived_t > | |
| k3d::interface_list< head_t, tail_t > | Used to create compile-time lists of interfaces (i.e. typelists - see Alexandrescu "Modern C++ Design") |
| k3d::iorthographic | Abstract interface encapsulating a standard orthographic transformation |
| k3d::iparentable | Abstract interface for an object that can be "parented" to another. Note: parenting implies, but does not require, that the child's transformations be related to the parent's |
| k3d::ipath_property | Abstract interface for properties that represent external filesystem resources (typically used to alter presentation) |
| k3d::ipath_property::pattern_filter | Defines a "pattern filter" that the UI layer can use to filter files using GLOB style syntax |
| k3d::ipersistent | Abstract interface implemented by objects that can be serialized to/from a K-3D document |
| k3d::ipersistent::load_context | Placeholder for arguments passed at load time |
| k3d::ipersistent::save_context | Placeholder for arguments passed at save time |
| k3d::ipersistent_collection | Encapsulates a collection of named, serializable objects |
| k3d::ipersistent_lookup | Abstract interface to assign / lookup unique identifiers for object serialization |
| k3d::iperspective | Abstract interface encapsulating a standard perspective (truncated pyramid, or frustum) transformation |
| k3d::ipipeline | Abstract interface for maintaining a collection of dependencies among properties ... a "pipeline" |
| k3d::ipipeline_profiler | Abstract interface for an object that collects and distributes profiling data for the K-3D visualization pipeline |
| k3d::ipipeline_profiler::profile | RAII helper class that records profile information for the current scope with return- and exception-safety |
| k3d::iplugin_factory | Abstract factory interface for plugin objects |
| k3d::iplugin_factory_collection | Abstract factory interface for plugin objects |
| k3d::iplugin_registry | Abstract interface passed to plugin module entry points so they may register their plugin factories |
| k3d::iprojection | Abstract interface encapsulating a 3D-to-2D viewing projection |
| k3d::iproperty | Abstract interface for a name-value pair with fixed type (note - if you want to write to a property, query for iwritable_property and be prepared for it to fail for read-only properties) |
| k3d::iproperty_collection | Abstract interface for a collection of iproperty objects |
| k3d::iproperty_group_collection | Provides an abstract interface grouping a collection of iproperty objects (for UI purposes) |
| k3d::iproperty_group_collection::group | Defines a grouped collection of properties |
| k3d::iproperty_sink | Abstract interface for objects that can be optionally 'bound' to a specific property |
| k3d::irender_animation | Abstract interface implemented by objects that can render a sequence of still images |
| k3d::irender_camera_animation | Abstract interface implemented by objects that can render a sequence of still images using a camera |
| k3d::irender_camera_frame | Abstract interface implemented by objects that can render a still image using a camera |
| k3d::irender_camera_preview | Abstract interface implemented by objects that can create a "preview" render of a scene using a camera |
| k3d::irender_frame | Abstract interface implemented by objects that can render a still image |
| k3d::irender_preview | Abstract interface implemented by objects that can render a "preview" image |
| k3d::ireset_properties | |
| k3d::is_selected | Functor object for deciding whether an object is selected (i.e. has a non-zero selection weight) |
| k3d::iscript_engine | Abstract interface implemented by objects that can execute scripts written in a specific scripting language |
| k3d::iscript_engine::context | Defines a collection of name-value pairs passed to a script that define its context (its execution environment) - how they are used is implementation-dependent (note that the names are merely suggestions, and may be changed or ignored at the whim of the implementation) |
| k3d::iscript_property | Abstract interface for properties that represent scripts (typically used to alter presentation) |
| k3d::iscripted_action | Abstract interface implemented by objects that can execute a script on-demand |
| k3d::iselectable | Abstract interface for an object that supports the "selection" concept, affecting downstream editing operations |
| k3d::isnap_source | Abstract interface for a "source" on a snappable object |
| k3d::isnap_target | Abstract interface for a "target" on a snappable object |
| k3d::isnappable | Abstract interface implemented by objects to which other objects can be interactively "snapped" |
| k3d::istate_container | Abstract interface for an object that stores state and can restore it on demand (memento design pattern) |
| k3d::istate_recorder | Abstract interface for an object that can store a hierarchical tree of state changes to the document |
| k3d::istate_recorder::node | Encapsulates a single "node" in the hierarchy of recorded state changes |
| k3d::istate_recorder_sink | Abstract interface for objects that can be optionally 'bound' to a specific state recorder |
| k3d::istreaming_bitmap_source | Abstract interface for an object that collects and distributes profiling data for the K-3D visualization pipeline |
| k3d::istring_source | Abstract interface for objects that can act as a source of string values |
| k3d::istuff | |
| k3d::itexture | Abstract interface implemented by objects that can act as geometric surface materials |
| k3d::itime_sink | Abstract interface for objects that can consume time data |
| k3d::itransform_array_1d | Abstract interface for a node that defines a 1-dimensional array of transformation matrices |
| k3d::itransform_array_2d | Abstract interface for a node that defines a 2-dimensional array of transformation matrices |
| k3d::itransform_array_3d | Abstract interface for a node that defines a 3-dimensional array of transformation matrices |
| k3d::iunknown | Interface from which all other K-3D interfaces derive |
| k3d::iuri_handler | Abstract interface for manipulating documents referenced by URI |
| k3d::iuser_interface | Abstract interface to common graphical-user-interface operations for use by objects |
| k3d::iuser_property | Abstract interface for properties that are custom (user) properties |
| k3d::ivector3_source | Abstract interface for objects that can act as a source of vector3 values |
| k3d::iwatched_path_property | Abstract interface for properties that represent external filesystem resources (typically used to alter presentation) |
| k3d::iwritable_property | Abstract interface for a property that can be written (see iproperty if you need to read the value of a property) |
| k3d::key_modifiers | |
| mesh_modifier | |
| k3d::line2 | Encapsulates a 2D line |
| k3d::line3 | Encapsulates a 3D line |
| k3d::linear_curve::const_primitive | Gathers the member arrays of a linear_curve primitive into a convenient package |
| k3d::linear_curve::primitive | Gathers the member arrays of a linear_curve primitive into a convenient package |
| k3d::material_sink< base_t > | Adds a boilerplate implementation of k3d::imaterial_sink to a base class, using the parameterized-inheritance idiom |
| k3d::matrix4 | A 4x4 matrix |
| k3d::matrix_source< base_t > | |
| k3d::measurement::angle | Defines an angular unit-of-measure |
| k3d::measurement::area | Defines a unit-of-measure for area |
| k3d::measurement::conversion::multiplicative | Conversion policy for real world units that can be converted solely through multiplication |
| k3d::measurement::conversion_proxy< quantity_t > | Defines a proxy object so we can do conversion-by-assignment |
| k3d::measurement::distance | Defines a unit-of-measure for distance |
| k3d::measurement::force | Defines a unit-of-measure for force |
| k3d::measurement::mass | Defines a unit-of-measure for mass |
| k3d::measurement::pressure | Defines a unit-of-measure for pressure |
| k3d::measurement::quantity< unit_t > | Defines a real-world quantity (a combination of value and unit) |
| k3d::measurement::time | Defines a unit-of-measure for time |
| k3d::measurement::unit< conversion_policy > | Defines a real-world unit of measure, including singular written name, plural written name, and functions to_si() and from_si() for converting quantities to-and-from their corresponding SI standard units |
| k3d::measurement::volume | Defines a unit-of-measure for volume |
| k3d::mesh | Encapsulates a hetereogenous collection of geometric primitives |
| k3d::mesh::primitive | Defines storage for a generic mesh primitive |
| k3d::mesh::primitives_t | Defines storage for a collection of primitives |
| k3d::mesh_deformation_modifier | Mesh modifier implementation for use in plugins that deform a mesh (modify its points) without altering topology. To create a plugin, derive from mesh_deformation_modifier and implement the on_deform_mesh() method |
| k3d::mesh_modifier< base_t > | |
| k3d::mesh_reader< base_t > | |
| k3d::mesh_selection_modifier< base_t > | Mesh modifier implementation for use in plugins that alter the selection state of a mesh without altering its topology or geometry. To create a plugin, derive from mesh_selection_modifier and implement the on_select_mesh() method |
| k3d::mesh_selection_sink< base_t > | |
| k3d::mesh_simple_deformation_modifier | Mesh modifier implementation for use in plugins that deform a mesh (modify its points) without altering topology, and based solely on the input point positions and selection. To create a plugin, derive from mesh_simple_deformation_modifier and implement the on_deform_mesh() method. If you are only modifying points but need more information about the input mesh, consider using mesh_deformation_modifier instead |
| k3d::mesh_sink< base_t > | |
| k3d::mesh_source< base_t > | |
| k3d::mesh_writer< base_t > | |
| k3d::metadata::property< property_t > | Wraps a k3d_data object to add metadata |
| k3d::metadata::storage | Provides a boilerplate implementation of imetadata |
| k3d::mime::handler_iterator | |
| k3d::mime::type | Defines storage for a MIME type (RFC 2046) |
| k3d::named_arrays | |
| k3d::named_tables | |
| k3d::network_render_farm | |
| k3d::network_render_farm::implementation | |
| k3d::network_render_frame | |
| k3d::network_render_frame::command | Defines a command to be executed |
| k3d::network_render_frame::copy_command | |
| k3d::network_render_frame::exec_command | |
| k3d::network_render_frame::view_command | |
| k3d::network_render_job | |
| k3d::ngui::alignment | |
| k3d::ngui::angle_axis::control | Provides a UI for modifying the orientation of an object |
| k3d::ngui::angle_axis::detail::data_proxy | Adapts a k3d::iproperty object for use with angle_axis::control |
| k3d::ngui::angle_axis::idata_proxy | Abstract interface for an object that proxies a data source for a orientation control (i.e. the "model" in model-view-controller) |
| k3d::ngui::angle_axis::spin_button_model | Adapts a spin button to control a single angle_axis coordinate (indentified by index) |
| k3d::ngui::application_state | This ugly little fellow stores global (application-wide) user interface state in one place to minimize coupling between UI components |
| k3d::ngui::application_state::implementation | |
| k3d::ngui::application_state::implementation::sort_by_title | Used to keep documents sorted in the "safe to close" dialog |
| k3d::ngui::application_window | Provides a standard top-level window that will be closed automatically if the application is closed |
| k3d::ngui::asynchronous_update | Mixin class that can be used to schedule updates that will only occur when the UI is idle |
| k3d::ngui::auto_property_page::control | Provides a widget that auto-generates controls for a collection of properties |
| k3d::ngui::auto_property_page::control::implementation | |
| k3d::ngui::auto_property_toolbar::bypass_property_proxy | Toggle_button model that turns a property-bypass into a togglable action |
| k3d::ngui::auto_property_toolbar::control | Provides a toolbar with an auto-generated collection of icons based on an object's capabilities / type |
| k3d::ngui::auto_property_toolbar::control::implementation | |
| k3d::ngui::basic_input_model | Implementation of input_model that synthesizes a more useful collection of input events |
| k3d::ngui::basic_input_model::implementation | |
| k3d::ngui::basic_viewport_input_model | Implementation of viewport_input_model that synthesizes a more useful collection of input events |
| k3d::ngui::basic_viewport_input_model::implementation | |
| k3d::ngui::bitmap_preview::control | Provides a UI for previewing bitmap images (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::bitmap_preview::data_proxy< data_t > | Provides an implementation of bitmap_preview::idata_proxy that supports any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::bitmap_preview::extract_alpha | |
| k3d::ngui::bitmap_preview::extract_rgb | |
| k3d::ngui::bitmap_preview::idata_proxy | Abstract interface for an object that proxies a data source for a bitmap_preview control (i.e. the "model" in model-view-controller) |
| k3d::ngui::bitmap_preview::property_proxy | Specialization of bitmap_preview::data_proxy for use with iproperty objects |
| k3d::ngui::bounding_box::control | Provides a UI for modifying the bounding_box of an object |
| k3d::ngui::bounding_box::detail::data_proxy | Adapts a k3d::iproperty object for use with bounding_box::control |
| k3d::ngui::bounding_box::idata_proxy | Abstract interface for an object that proxies a data source for a bounding_box control (i.e. the "model" in model-view-controller) |
| k3d::ngui::bounding_box::spin_button_model | Adapts a spin button to control a single bounding_box coordinate |
| k3d::ngui::center_justify | |
| k3d::ngui::check_button::control | Provides a UI for manipulating boolean quantities (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::check_button::data_proxy< data_t > | Provides an implementation of k3d::check_button::idata_proxy that supports any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::check_button::data_proxy< k3d::iproperty > | Specialization of k3d::check_button::data_proxy for use with k3d::iproperty objects |
| k3d::ngui::check_button::idata_proxy | Abstract interface for an object that proxies a data source for a check button control (i.e. the "model" in model-view-controller) |
| k3d::ngui::check_menu_item::control | Provides a UI for manipulating boolean quantities (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::check_menu_item::data_proxy< data_t > | Provides an implementation of k3d::check_menu_item::idata_proxy that supports any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::check_menu_item::data_proxy< k3d::iproperty > | Specialization of k3d::check_menu_item::data_proxy for use with k3d::iproperty objects |
| k3d::ngui::check_menu_item::idata_proxy | Abstract interface for an object that proxies a data source for a toggle button control (i.e. the "model" in model-view-controller) |
| k3d::ngui::collapsible_frame::control | Provides a container that can be manually collapsed / expanded by users to reduce clutter |
| k3d::ngui::collapsible_frame::control::implementation | |
| k3d::ngui::collapsible_frame::group | Groups a collection of control objects together so they can be expanded / collapsed as a set |
| k3d::ngui::collapsible_frame::group::implementation | |
| k3d::ngui::color_chooser::control | Provides a UI for manipulating colors (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::color_chooser::data_proxy< data_t > | Provides an implementation of k3d::color_chooser::idata_proxy that supports any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::color_chooser::data_proxy< k3d::iproperty > | Specialization of k3d::color_chooser::data_proxy for use with k3d::iproperty objects |
| k3d::ngui::color_chooser::detail::color_selection_dialog | Tutorial-enabled implementation of a standard color selection dialog |
| k3d::ngui::color_chooser::idata_proxy | Abstract interface for an object that proxies a data source for a color chooser control (i.e. the "model" in model-view-controller) |
| k3d::ngui::combo_box::control | Provides a UI for manipulating enumerated quantities (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::combo_box::control::columns | Defines a data model for the underlying combo box widget |
| k3d::ngui::combo_box::data_proxy< data_t > | Provides an implementation of k3d::combo_box::idata_proxy that supports any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::combo_box::data_proxy< k3d::iproperty > | Specialization of k3d::combo_box::data_proxy for use with k3d::iproperty objects |
| k3d::ngui::combo_box::idata_proxy | Abstract interface for an object that proxies a data source for a combo_box control (i.e. the "model" in model-view-controller) |
| k3d::ngui::connect_button | Convenience object for connecting a button to a slot inline |
| k3d::ngui::connect_menu_item | Convenience object for connecting a menu item to a slot inline |
| k3d::ngui::connect_signal_changed | Convenience object for connecting a menu item to a slot inline |
| k3d::ngui::console::control | Provides a "console" control that can be used for line-oriented output |
| k3d::ngui::console::control::implementation | |
| k3d::ngui::custom_property::control | |
| k3d::ngui::custom_property_page::control | Abstract interface for a custom "property page", a UI component that can be displayed in-place-of the normal "auto-generated" property page for a specific plugin |
| k3d::ngui::detail::AccelPath | Duplicated from GTK sources because there's no gtk_widget_get_accel_path() |
| k3d::ngui::detail::animation_chooser_dialog | Prompt the user to choose a range of files for saving an animation |
| k3d::ngui::detail::animation_sample_columns | |
| k3d::ngui::detail::camera_columns | |
| k3d::ngui::detail::camera_separators | |
| k3d::ngui::detail::imanipulators< Type > | |
| k3d::ngui::detail::move_manipulators | |
| k3d::ngui::detail::move_manipulators::constraint | |
| k3d::ngui::detail::node_context_menu | Provides a standardized context menu for nodes |
| k3d::ngui::detail::point_visitor | Expands a bounding box around the visited points |
| k3d::ngui::detail::render_engine_columns | |
| k3d::ngui::detail::render_engine_separators | |
| k3d::ngui::detail::rotate_manipulators | |
| k3d::ngui::detail::rotate_manipulators::constraint | |
| k3d::ngui::detail::scale_manipulators | |
| k3d::ngui::detail::scale_manipulators::constraint | |
| k3d::ngui::detail::select | |
| k3d::ngui::document_state | This ugly little fellow stores document-wide user interface state in one place to minimize coupling between the various per-document UI components |
| k3d::ngui::document_state::implementation | |
| k3d::ngui::document_state::implementation::sort_by_title | Used to keep documents sorted in the "safe to close" dialog |
| k3d::ngui::document_window | Provides a standard document-level window |
| k3d::ngui::enable_dynamic_accelerators | |
| k3d::ngui::entry::control | Provides a standard UI control for manipulating text fields (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::entry::control::implementation | |
| k3d::ngui::entry::generic_model_t< data_t > | Provides an implementation of entry::imodel that can "wrap" any data source that supports the internal_value(), set_value(), and changed_signal() concepts |
| k3d::ngui::entry::imodel | Abstract data model for an entry::control |
| k3d::ngui::entry::property_model | Implementation of entry::imodel for use with k3d::iproperty objects |
| k3d::ngui::enumeration_chooser::control | Provides a UI for manipulating enumerated quantities (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::enumeration_chooser::control::implementation | |
| k3d::ngui::enumeration_chooser::control::implementation::columns | Defines a data model for the underlying combo box widget |
| k3d::ngui::enumeration_chooser::imodel | Abstract data model for an enumeration_chooser::control |
| k3d::ngui::enumeration_chooser::property_model | Implementation of enumeration_chooser::imodel for use with k3d::iproperty objects |
| k3d::ngui::event_button | Defines a push-button that can handle any button event, not just LMB-click |
| k3d::ngui::file_chooser_dialog | Wraps the standard file dialog widget, adding K-3D-specific functionality |
| k3d::ngui::hotkey_cell_renderer_text | Gtk::CellRendererText derivative that automatically disables accelerators during editing |
| k3d::ngui::hotkey_entry | Gtk::Entry derivative that automatically disables accelerators while it has the focus |
| k3d::ngui::image_toggle_button::control | Specialization of toggle_button::control that displays different images dependent on the button state |
| k3d::ngui::input_model | Abstract interface for objects that can process user input |
| k3d::ngui::line_wrap | |
| k3d::ngui::main_document_window | |
| k3d::ngui::main_document_window::import_export_columns | |
| k3d::ngui::make_toolbar_button | |
| k3d::ngui::merge_nodes::detail::merge_nodes_dialog | |
| k3d::ngui::merge_nodes::detail::merge_nodes_dialog::columns_t | |
| k3d::ngui::merge_nodes::detail::node_check_t | |
| k3d::ngui::mesh_modifier | |
| k3d::ngui::move_tool | Implementation of tool that implements standard geometry move behavior |
| k3d::ngui::navigation_input_model | Input model implementation that handles standard viewport navigation and context menus |
| k3d::ngui::navigation_input_model::implementation | |
| k3d::ngui::node_chooser::control | Provides a UI for choosing nodes (either existing, or newly-created) (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::node_chooser::data_proxy< data_t > | Provides an implementation of k3d::node_chooser::idata_proxy that supports any data source that supports the node(), set_node(), node_collection(), and changed_signal() concepts |
| k3d::ngui::node_chooser::data_proxy< k3d::iproperty > | Specialization of k3d::node_chooser::data_proxy for use with k3d::iproperty objects |
| k3d::ngui::node_chooser::detail::property_filter | Provides an implementation of k3d::node_chooser::iselection_filter that filters based on a k3d::iproperty node |
| k3d::ngui::node_chooser::idata_proxy | Abstract interface for an node that proxies a data source for an node_chooser::control (i.e. the "model" in model-view-controller) |
| k3d::ngui::node_chooser::iselection_filter | Abstract interface for an node that will be queried to filter the set of available choices |
| k3d::ngui::node_chooser::selection_filter< interface_t > | Provides an implementation of k3d::node_chooser::iselection_filter that filters based on a specific interface type |
| k3d::ngui::node_collection_chooser::control | Provides a UI for selecting a set of nodes |
| k3d::ngui::node_collection_chooser::control::implementation | |
| k3d::ngui::node_collection_chooser::imodel | Abstract data model for a node_collection_chooser::control |
| k3d::ngui::node_collection_chooser::list_window | |
| k3d::ngui::node_collection_chooser::list_window::columns | |
| k3d::ngui::node_collection_chooser::property_model | |
| k3d::ngui::node_window | Provides a standard node-level window |
| k3d::ngui::node_window::implementation | |
| k3d::ngui::null_viewport_input_model | Do-nothing implementation of viewport_input_model |
| k3d::ngui::panel::control | Abstract interface for a "panel", a UI component that can be "mounted" in a panel_container |
| k3d::ngui::panel::mediator | Mediates interaction between panels on a per-document basis |
| k3d::ngui::panel::mediator::implementation | |
| k3d::ngui::panel_frame::control | Provides a "panel frame" control that can "mount" a panel control |
| k3d::ngui::panel_frame::control::columns | |
| k3d::ngui::panel_frame::detail::floating_window | |
| k3d::ngui::path_chooser::control | Provides a standard UI control for manipulating filepath data (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::path_chooser::control::reference_columns | |
| k3d::ngui::path_chooser::data_proxy< data_t > | Provides an implementation of k3d::path_chooser::idata_proxy that supports any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::path_chooser::data_proxy< k3d::iproperty > | Specialization of k3d::path_chooser::data_proxy for use with k3d::iproperty objects |
| k3d::ngui::path_chooser::idata_proxy | Abstract interface for an object that proxies a data source for an path control (i.e. the "model" in model-view-controller) |
| k3d::ngui::point::control | Provides a UI for modifying the point of an object |
| k3d::ngui::point::detail::data_proxy | Adapts a k3d::iproperty object for use with point::control |
| k3d::ngui::point::idata_proxy | Abstract interface for an object that proxies a data source for a point control (i.e. the "model" in model-view-controller) |
| k3d::ngui::point::spin_button_model | Adapts a spin button to control a single point coordinate (indentified by index) |
| k3d::ngui::property::create_dialog | Implements a dialog for adding custom user properties to a node |
| k3d::ngui::property_button::control | Provides a UI for manipulating properties (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::property_label::control | Provides a UI for manipulating properties (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::property_widget::control | Provides a UI for manipulating properties (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::property_widget::data_proxy< data_t > | Provides an implementation of property_widget::idata_proxy that supports any data source that supports the property() concept |
| k3d::ngui::property_widget::data_proxy< k3d::iproperty > | Specialization of property_widget::data_proxy for use directly with iproperty objects |
| k3d::ngui::property_widget::idata_proxy | Abstract interface for an object that proxies a data source for a property_widget (i.e. the "model" in model-view-controller) |
| k3d::ngui::right_justify | |
| k3d::ngui::rotate_tool | Tool implementation that provides object/mesh rotation behavior |
| k3d::ngui::safe_close_dialog::detail::unsaved_document_columns | |
| k3d::ngui::safe_close_dialog::entry | Encapsulates an entry in the safe close dialog |
| k3d::ngui::savable_application_window | Provides a standard top-level window for application-level documents that can be saved |
| k3d::ngui::savable_document_window | Provides a standard document-level window |
| k3d::ngui::scale_tool | Tool implementation that provides standard node/mesh scaling |
| k3d::ngui::screen_overlay | Provides an interface for drawing transparent displays over the top of the user's screen |
| k3d::ngui::script_button::control | Provides a UI for manipulating script data (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::script_button::imodel | Abstract interface for an object that proxies a data source for a script button control (i.e. the "model" in model-view-controller) |
| k3d::ngui::script_button::property_model | Implementation of script_button::imodel for use with iproperty objects |
| k3d::ngui::selection::detail::deselect_all | Update policy for use with replace_selection() that deselects all points and primitives in a mesh |
| k3d::ngui::selection::detail::invert_components | Update policy for use with replace_selection() that inverts the selection of a specific component type in a mesh |
| k3d::ngui::selection::detail::invert_components::generate_selection | |
| k3d::ngui::selection::detail::invert_points | Update policy for use with replace_selection() that inverts the selection of all points in a mesh |
| k3d::ngui::selection::detail::select_all_components | Update policy for use with replace_selection() that selects all components of a given type in a mesh |
| k3d::ngui::selection::detail::select_all_points | Update policy for use with replace_selection() that selects all points in a mesh |
| k3d::ngui::selection::detail::select_component | Policy class that updates a mesh_selection to select the given components |
| k3d::ngui::selection::detail::select_edges | Policy class that updates a mesh_selection to select the given edges |
| k3d::ngui::selection::detail::select_points | Policy class that updates a mesh_selection to select the given points |
| k3d::ngui::selection::state | Provides convenience methods for manipulating the selection state of a document |
| k3d::ngui::selection::state::implementation | |
| k3d::ngui::selection_input_model | Input model implementation that handles interactive selection |
| k3d::ngui::selection_input_model::implementation | |
| k3d::ngui::selection_tool | Tool implementation that provides geometry selection and viewport navigation |
| k3d::ngui::selection_tool::implementation | |
| k3d::ngui::set_accelerator_path | |
| k3d::ngui::set_insensitive | Convenience object for disabling a widget inline |
| k3d::ngui::set_markup | |
| k3d::ngui::set_tooltip | Convenience object for setting the tooltip on a component inline |
| k3d::ngui::show_history | Helper class for dumping history to a stream for debugging |
| k3d::ngui::spin_button::control | Provides a UI for manipulating scalar quantities (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::spin_button::control::implementation | |
| k3d::ngui::spin_button::generic_model_t< value_t, data_t > | Provides an implementation of spin_button::imodel that can "wrap" any data source that supports the internal_value(), set_value(), and changed_signal() concepts |
| k3d::ngui::spin_button::imodel | Abstract data model for a spin_button::control |
| k3d::ngui::spin_button::property_model | Implementation of spin_button::imodel for use with k3d::iproperty objects |
| k3d::ngui::text::control | Provides a standard UI control for manipulating text fields (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::text::control::implementation | |
| k3d::ngui::text::generic_model_t< data_t > | Provides an implementation of text::imodel that can "wrap" any data source that supports the internal_value(), set_value(), and changed_signal() concepts |
| k3d::ngui::text::imodel | Abstract data model for an text::control |
| k3d::ngui::text::property_model | Implementation of text::imodel for use with k3d::iproperty objects |
| k3d::ngui::toggle_button::control | Provides a UI for manipulating boolean quantities (i.e. the view and the controller from model-view-controller) |
| k3d::ngui::toggle_button::generic_model_t< data_t > | Provides an implementation of k3d::toggle_button::imodel that can "wrap" any data source that supports the value(), set_value(), and changed_signal() concepts |
| k3d::ngui::toggle_button::imodel | Abstract data model for toggle_button::control objects |
| k3d::ngui::tool | Abstract base class for Tools - objects that generate state changes based on user interaction with viewports |
| k3d::ngui::tool_selection | |
| k3d::ngui::toolbar::control | Provides a standard toolbar control |
| k3d::ngui::transform_modifier | |
| k3d::ngui::transform_tool | |
| k3d::ngui::transform_tool::itarget | Stores an object to be moved interactively |
| k3d::ngui::transform_tool::mesh_target | |
| k3d::ngui::transform_tool::transform_target | |
| k3d::ngui::unsaved_document | Abstract interface class for UI components that may encapsulate an unsaved document |
| k3d::ngui::viewport::control | |
| k3d::ngui::viewport::control::implementation | |
| k3d::ngui::viewport::detail::hit_iterator | Input iterator that extracts objects of type hit_record from a flat buffer |
| k3d::ngui::viewport::detail::hit_record | Wrapper class for OpenGL hit records - designed to resemble an STL container |
| k3d::ngui::viewport::detail::sort_by_zmin | |
| k3d::ngui::viewport_input_model | Abstract interface for objects that can process user input |
| k3d::node | |
| k3d::node_change_signal< derived_t > | Provides a mixin-class implementation of k3d::inode_change_signal |
| k3d::node_name_map | Concrete implementation of inode_name_map that generates repeatable unique node names for use by e.g: tutorial recording and playback |
| k3d::node_name_map::implementation | |
| k3d::noise::classic3 | Noise generator that returns "classic" Perlin 3D noise in the range (-1, 1) |
| k3d::normal3 | Encapsulates a 3D surface normal |
| k3d::null_interface | Defines a null interface type for marking the ends of an interface list |
| k3d::nurbs_curve::const_primitive | Gathers the member arrays of a nurbs_curve primitive into a convenient package |
| k3d::nurbs_curve::primitive | Gathers the member arrays of a nurbs_curve primitive into a convenient package |
| k3d::nurbs_patch::const_primitive | Gathers the member arrays of a nurbs_patch primitive into a convenient package |
| k3d::nurbs_patch::primitive | Gathers the member arrays of a nurbs_patch primitive into a convenient package |
| k3d::options::file_storage | Trivial implementation of k3d::istorage that serializes data to an XML file |
| k3d::options::file_storage::implementation | |
| k3d::options::istorage | Abstract interface for global user option storage |
| k3d::paraboloid::const_primitive | Gathers the member arrays of a paraboloid primitive into a convenient package |
| k3d::paraboloid::primitive | Gathers the member arrays of a paraboloid primitive into a convenient package |
| k3d::parallel::blocked_range< ValueT > | |
| k3d::parentable< base_t > | Provides a boilerplate implementation of an object that can be parented to another |
| k3d::particle::const_primitive | Gathers the member arrays of a particle primitive into a convenient package |
| k3d::particle::primitive | Gathers the member arrays of a particle primitive into a convenient package |
| k3d::persistent_lookup | Concrete implementation of ipersistent_lookup |
| k3d::persistent_property_collection | Automates serialization of properties |
| k3d::pipeline | Provides a concrete implementation of ipipeline that can be used to manage arbitrary connections between properties |
| k3d::pipeline::implementation | |
| k3d::pipeline::implementation::delete_property_container | Used to implement undo/redo state changes when a pipeline property has been deleted |
| k3d::pipeline::implementation::set_dependencies_container | Used to implement undo/redo state changes when pipeline connections are modified |
| k3d::pipeline_data< T > | |
| k3d::pipeline_data_traits< T > | |
| k3d::pipeline_data_traits< array > | Specialization of pipeline_data_traits for use with k3d::array |
| k3d::pipeline_profiler | Concrete implementation of ipipeline_profiler that collects and distributes profiling data for the K-3D visualization pipeline |
| k3d::pipeline_profiler::implementation | |
| k3d::plane | Encapsulates a 3D plane surface |
| k3d::plugin_factory | Provides a boilerplate implementation of iplugin_factory |
| k3d::plugin_factory_collection | Provides an implementation of iplugin_factory_collection that can load plugin factories from shared libraries |
| k3d::plugin_factory_collection::implementation | |
| k3d::point2 | Encapsulates a location in two-dimensional space |
| k3d::point3 | Encapsulates a location in three-dimensional space |
| k3d::point4 | Encapsulates a four-dimensional location |
| k3d::polyhedron::const_primitive | Gathers the member arrays of a polyhedron primitive into a convenient package |
| k3d::polyhedron::detail::create_triangles | |
| k3d::polyhedron::detail::create_triangles::new_edge_record | |
| k3d::polyhedron::detail::find_companion_worker | |
| k3d::polyhedron::primitive | Gathers the member arrays of a polyhedron primitive into a convenient package |
| k3d::progress_timer | Measures elapsed time using a high-resolution timer, printing the results to a stream on destruction. Intentionally modelled on boost::progress_timer |
| k3d::property::detail::null_property_collection | This is an ugly hack, but it allows user properties to be fully constructed before they're added to their property collection |
| k3d::property::detail::property_factory | Helper class for instantiating user property instances |
| k3d::property::detail::renderman_attribute_factory | Helper class for instantiating user property instances |
| k3d::property::detail::renderman_attribute_property< value_t, name_policy_t > | Property policy that exposes a data container as a K-3D renderman property |
| k3d::property::detail::renderman_attribute_serialization< value_t, property_policy_t > | Serialization policy for data containers that can be serialized as XML |
| k3d::property::detail::renderman_option_factory | Helper class for instantiating user property instances |
| k3d::property::detail::renderman_option_property< value_t, name_policy_t > | Property policy that exposes a data container as a K-3D renderman property |
| k3d::property::detail::renderman_option_serialization< value_t, property_policy_t > | Serialization policy for data containers that can be serialized as XML |
| k3d::property::detail::renderman_parameter_list_name_t | Helper class used to set a renderman property's parameter list name |
| k3d::property::detail::user_mesh_serialization< value_t, property_policy_t > | Serialization policy for generic user properties that store k3d::mesh |
| k3d::property::detail::user_node_serialization< value_t, property_policy_t > | Serialization policy for data containers that store a document node and can be serialized as XML |
| k3d::property::detail::user_property< property_t > | Wraps a k3d_data object to mark it as a user property |
| k3d::property::detail::user_serialization< value_t, property_policy_t > | Serialization policy for generic user properties |
| k3d::property_collection | Provides a default implementation of iproperty_collection |
| k3d::property_group_collection | Provides a default implementation of iproperty_group_collection |
| k3d::python::atk | |
| k3d::python::bezier_triangle_patch | |
| k3d::python::bezier_triangle_patch::const_primitive | |
| k3d::python::bezier_triangle_patch::primitive | |
| k3d::python::bicubic_patch | |
| k3d::python::bicubic_patch::const_primitive | |
| k3d::python::bicubic_patch::primitive | |
| k3d::python::bilinear_patch | |
| k3d::python::bilinear_patch::const_primitive | |
| k3d::python::bilinear_patch::primitive | |
| k3d::python::blobby | |
| k3d::python::blobby::const_primitive | |
| k3d::python::blobby::primitive | |
| k3d::python::cone | |
| k3d::python::cone::const_primitive | |
| k3d::python::cone::primitive | |
| k3d::python::const_typed_array_array_factory | |
| k3d::python::cubic_curve | |
| k3d::python::cubic_curve::const_primitive | |
| k3d::python::cubic_curve::primitive | |
| k3d::python::cylinder | |
| k3d::python::cylinder::const_primitive | |
| k3d::python::cylinder::primitive | |
| k3d::python::detail::role_method_creator | |
| k3d::python::difference | |
| k3d::python::disk | |
| k3d::python::disk::const_primitive | |
| k3d::python::disk::primitive | |
| k3d::python::euler | |
| k3d::python::file_change_receiver | |
| k3d::python::file_signal | |
| k3d::python::filesystem | |
| k3d::python::geometry | |
| k3d::python::geometry::point_selection | |
| k3d::python::geometry::point_selection::const_storage | |
| k3d::python::geometry::point_selection::storage | |
| k3d::python::geometry::primitive_selection | |
| k3d::python::geometry::primitive_selection::const_storage | |
| k3d::python::geometry::primitive_selection::storage | |
| k3d::python::geometry::selection | |
| k3d::python::hyperboloid | |
| k3d::python::hyperboloid::const_primitive | |
| k3d::python::hyperboloid::primitive | |
| k3d::python::instance_wrapper< T > | |
| k3d::python::linear_curve | |
| k3d::python::linear_curve::const_primitive | |
| k3d::python::linear_curve::primitive | |
| k3d::python::log | |
| k3d::python::mime | |
| k3d::python::mime::type | |
| k3d::python::named_arrays_array_factory | |
| k3d::python::node | |
| k3d::python::nurbs_curve | |
| k3d::python::nurbs_curve::const_primitive | |
| k3d::python::nurbs_curve::primitive | |
| k3d::python::nurbs_patch | |
| k3d::python::nurbs_patch::const_primitive | |
| k3d::python::nurbs_patch::primitive | |
| k3d::python::owned_instance_wrapper< T > | |
| k3d::python::paraboloid | |
| k3d::python::paraboloid::const_primitive | |
| k3d::python::paraboloid::primitive | |
| k3d::python::parallel | |
| k3d::python::particle | |
| k3d::python::particle::const_primitive | |
| k3d::python::particle::primitive | |
| k3d::python::plugin | |
| k3d::python::plugin::factory | |
| k3d::python::polyhedron | |
| k3d::python::polyhedron::const_primitive | |
| k3d::python::polyhedron::primitive | |
| k3d::python::property | |
| k3d::python::property::ri | |
| k3d::python::resource | |
| k3d::python::ri | |
| k3d::python::script | |
| k3d::python::selection | |
| k3d::python::sphere | |
| k3d::python::sphere::const_primitive | |
| k3d::python::sphere::primitive | |
| k3d::python::table_array_factory | |
| k3d::python::teapot | |
| k3d::python::teapot::const_primitive | |
| k3d::python::teapot::primitive | |
| k3d::python::torus | |
| k3d::python::torus::const_primitive | |
| k3d::python::torus::primitive | |
| k3d::python::typed_array_array_factory | |
| k3d::qtui::action | |
| k3d::qtui::application | Provides a singleton for managing the running K-3D application |
| k3d::qtui::application_widget | Provides a mixin-class for widgets that should be closed automatically if the application is closed |
| k3d::qtui::console::widget | Provides a "console" widget that can be used for line-oriented output |
| k3d::qtui::console::widget::implementation | |
| k3d::qtui::document_widget | Provides a mixin-class for widgets that should be closed automatically if a document is closed |
| k3d::qtui::file_dialog | |
| k3d::qtui::focus::mediator | Mediates access to a per-document "focus" object |
| k3d::qtui::focus::mediator::implementation | |
| k3d::qtui::icon_factory | Generates icons |
| k3d::qtui::modal_text_editor | |
| k3d::qtui::mode | |
| k3d::qtui::nag_message_dialog | Provides a mixin-class for widgets that should be closed automatically if a document is closed |
| k3d::qtui::node_list_model | Exposes a list of K-3D nodes as a flat list suitable for use with Qt views |
| k3d::qtui::panel | |
| k3d::qtui::property_widget | |
| k3d::qtui::property_widget_factory | Generates widgets that can act as proxies for k3d::iproperty objects |
| k3d::qtui::selection::detail::deselect_all | Update policy for use with replace_selection() that deselects all points and primitives in a mesh |
| k3d::qtui::selection::detail::invert_components | Update policy for use with replace_selection() that inverts the selection of a specific component type in a mesh |
| k3d::qtui::selection::detail::invert_components::generate_selection | |
| k3d::qtui::selection::detail::invert_points | Update policy for use with replace_selection() that inverts the selection of all points in a mesh |
| k3d::qtui::selection::detail::select_all_components | Update policy for use with replace_selection() that selects all components of a given type in a mesh |
| k3d::qtui::selection::detail::select_all_points | Update policy for use with replace_selection() that selects all points in a mesh |
| k3d::qtui::selection::detail::select_component | Policy class that updates a mesh_selection to select the given components |
| k3d::qtui::selection::detail::select_edges | Policy class that updates a mesh_selection to select the given edges |
| k3d::qtui::selection::detail::select_points | Policy class that updates a mesh_selection to select the given points |
| k3d::qtui::selection::state | Provides convenience methods for manipulating the selection state of a document |
| k3d::qtui::selection::state::implementation | |
| k3d::quaternion | Encapsulates a quaternion |
| k3d::record_state_change_set | RAII helper class that provides a return- and exception-safe way to record state changes for UNDO purposes |
| k3d::rectangle | Provides storage for a two-dimensional rectangle |
| k3d::resolution | Encapsulates a named image resolution |
| k3d::resource::record | Storage for a single resource |
| k3d::ri::format_array_t< iterator_t, value_t > | Formats an array of values within square brackets for inclusion in a RIB file; designed to be used as an inline formatting object |
| k3d::ri::format_array_t< iterator_t, k3d::ri::string > | Partial specialization of format_array_t for use with string values |
| k3d::ri::format_matrix | Formats a matrix for inclusion in a RIB file; designed to be used as an inline formatting object |
| k3d::ri::format_string | Formats a string with real-quotes for inclusion in a RIB file; designed to be used as an inline formatting object |
| k3d::ri::iattribute_property | Abstract interface for discovering information about a RenderMan attribute property |
| k3d::ri::idisplacement_shader | Abstract interface implemented by objects that encapsulate a RenderMan displacement shader |
| k3d::ri::iimager_shader | Abstract interface implemented by objects that encapsulate a RenderMan imager shader |
| k3d::ri::ilight | Abstract interface for objects that can act as light sources while drawing RenderMan graphics |
| k3d::ri::ilight_shader | Abstract interface implemented by objects that encapsulate a RenderMan light shader |
| k3d::ri::imaterial | Abstract interface implemented by objects that can act as a surface material while drawing RenderMan graphics |
| k3d::ri::imesh_painter | Abstract interface implemented by painter objects that can render a mesh using RenderMan |
| k3d::ri::ioption_property | Abstract interface for discovering information about a RenderMan option property |
| k3d::ri::irender_engine | Abstract interface for objects that provide an interface to specific RenderMan implementations |
| k3d::ri::irenderable | Abstract interface for objects that can render themselves using the RenderMan API |
| k3d::ri::ishader_collection | Abstract interface to a collection of RenderMan shaders stored by source path (used to keep track of shaders that need to be compiled) |
| k3d::ri::istream | Abstract binding to the Pixar RenderMan interface |
| k3d::ri::isurface_shader | Abstract interface implemented by objects that encapsulate a RenderMan surface shader |
| k3d::ri::itexture | Abstract interface implemented by objects that can act as texture sources while drawing RenderMan graphics |
| k3d::ri::ivolume_shader | Abstract interface implemented by objects that encapsulate a RenderMan volume shader |
| k3d::ri::parameter | Defines a named array of homogeneous RenderMan data |
| k3d::ri::render_state | Used to pass (potentially) useful rendering state from the renderer to the object being rendered |
| k3d::ri::renderable< base_t > | Adds a boilerplate implementation of k3d::ri::irender to a transformable base class, using the parameterized inheritance idiom |
| k3d::ri::shader | Abstract base class that provides most of the boilerplate for a RenderMan shader instance |
| k3d::ri::shader_collection | Provides a boilerplate implementation of k3d::ri::ishader_collection |
| k3d::ri::shader_collection::implementation | |
| k3d::ri::stream | Provides a boilerplate implementation of k3d::ri::istream that writes RIB to a stream |
| k3d::ri::stream::implementation | |
| k3d::scalar_source | Convenience base-class for sources / filters that produce a scalar output value |
| k3d::script::code | Helper class that converts various forms of input into script code that can be executed |
| k3d::script::language | Helper class that converts various forms of input into an identifiable script language |
| k3d::scripted_node< base_t > | Uses parameterized inheritance to provide a boilerplate implementation for nodes that are controlled by scripts |
| k3d::scripted_node< base_t >::execute_lock | RAII helper class that keeps track of whether we're executing, so we can avoid recursive loops |
| k3d::scripted_plugin< base_t > | Convenience class for application plugins that need to call scripts |
| k3d::sds::catmull_clark_subdivider | Stores a hierarchy of Catmull-Clark levels, and provides methods to create and update this hierarchy |
| k3d::sds::catmull_clark_subdivider::implementation | |
| k3d::sds::catmull_clark_subdivider::implementation::polyhedron | |
| k3d::sds::catmull_clark_subdivider::implementation::topology_data_t | Some arrays containing additional topology data |
| k3d::sds::detail::corner_point_calculator | Calculates patch corner positions |
| k3d::sds::detail::corner_worker | Helper for TBB |
| k3d::sds::detail::edge_midpoint_calculator | Calculates edge midpoints |
| k3d::sds::detail::face_center_calculator | Calculates face centers |
| k3d::sds::detail::mesh_arrays | Stores references to commonly used arrays, and defines some common checks for faces and edges |
| k3d::sds::detail::per_face_component_counter | For each old face index, count the number of subfaces, loops, edges and distinct points that will be in the new mesh |
| k3d::sds::detail::point_index_calculator | Calculates the new indices of corner points, edge midpoints and face centers |
| k3d::sds::detail::topology_subdivider | Create the subdivided mesh topology |
| k3d::sds::detail::worker< FunctorT > | |
| k3d::sds::ipatch_boundary_visitor | Visitor used to collect information about the patch boundaries of the SDS surface |
| k3d::sds::ipatch_corner_visitor | Visitor used to collect information about patch corners of the SDS surface |
| k3d::sds::ipatch_surface_visitor | Visitor used to collect information about the SDS surface |
| k3d::selectable | Provides a boilerplate implementation of k3d::iselectable |
| k3d::selection::record | |
| k3d::selection::set | Defines a container of selection::storage objects |
| k3d::selection::set_weight | Functor object for setting selection weight on a collection of objects - good with k3d::for_each_component |
| k3d::selection::storage | Defines storage for a generic selection |
| k3d::selection::token | |
| k3d::selection_set_serialization< value_t, property_policy_t > | K3d::data serialization policy for use with k3d::selection |
| k3d::signal::cancelable | |
| k3d::signal::consumable | |
| k3d::signal::loop_safe_slot< SignalT > | |
| k3d::sl::argument | Encapsulates an argument to a Pixar RenderMan Shading Language shader |
| k3d::sl::detail::point3 | |
| k3d::sl::shader | Encapsulates a Pixar RenderMan Shading Language shader |
| k3d::snap_source | |
| k3d::snap_target | |
| k3d::snappable< base_t > | Provides a boilerplate implementation of k3d::isnappable for objects that can be interactively "snapped" |
| k3d::snappable_detail | Provides a boilerplate implementation of k3d::isnappable for objects that can be interactively "snapped" |
| k3d::socket::closed | Exception thrown when the opposite end of a connection has closed |
| k3d::socket::endpoint | Encapsulates one end of an open socket connection |
| k3d::socket::endpoint::implementation | Provides a posix implementation of k3d::socket::endpoint |
| k3d::socket::exception | Base-class for all exceptions thrown by sockets |
| k3d::socket::would_block | Exception thrown when a non-blocking socket operation would block |
| k3d::sort_by_name | Convenience functor for sorting factory collections and nodes alphabetically by name |
| k3d::sphere::const_primitive | Gathers the member arrays of a sphere primitive into a convenient package |
| k3d::sphere::primitive | Gathers the member arrays of a sphere primitive into a convenient package |
| k3d::start_block | |
| k3d::state_change_set | Stores an atomic set of state changes that can be undone / redone |
| k3d::state_change_set::implementation | |
| k3d::string_source< derived_t > | |
| k3d::table | |
| k3d::table_copier | Handles random-access copying among attribute arrays |
| k3d::table_copier::copy_policy | Abstract interface for policy objects that determine which source arrays get copied to which target arrays |
| k3d::table_copier::copy_subset | |
| k3d::table_copier::implementation | |
| k3d::table_copier::implementation::array_copier | Abstract interface for concrete objects that provide array-copying operations |
| k3d::table_copier::implementation::copier_factory | Helper class that instantiates array_copier objects based on the runtime type of source and target arrays |
| k3d::table_copier::implementation::copier_factory::typed_array_copier< array_t > | Concrete array_copier implementation that is templated on the array type |
| k3d::table_copier::strict_copy | |
| k3d::teapot::const_primitive | Gathers the member arrays of a teapot primitive into a convenient package |
| k3d::teapot::primitive | Gathers the member arrays of a teapot primitive into a convenient package |
| k3d::texture3 | Encapsulates a location in three-dimensional space |
| k3d::time_sink< base_t > | Adds a boilerplate implementation of k3d::itime_sink to a base class, using the parameterized-inheritance idiom |
| k3d::timer | Measures elapsed time using a high-resolution timer. Intentionally modelled on boost::timer |
| k3d::torus::const_primitive | Gathers the member arrays of a torus primitive into a convenient package |
| k3d::torus::primitive | Gathers the member arrays of a torus primitive into a convenient package |
| k3d::transformable< base_t > | Provides a boilerplate implementation of an object that can act as a matrix source and sink |
| k3d::triangulator | |
| k3d::triangulator::implementation | |
| k3d::typed_array< T > | Strongly-typed dynamic array of objects, based on std::vector |
| k3d::uint_t_array | |
| k3d::user::property_container | Istate_container implementation that handles undo/redo for the set of user properties within a property collection |
| k3d::user_property_changed_signal | Tracks user properties as they are added/removed from a property collection, and emits a signal whenever any user property value changeds |
| k3d::ustring | UTF-8 string class that is based on Glib::ustring, with some omissions |
| k3d::uuid | Identifier used to uniquely identify plugin modules and plugin objects |
| k3d::vector2 | Encapsulates a direction vector in two-dimensional space |
| k3d::vector3 | Encapsulates a direction vector in three-dimensional space |
| k3d::vector3_source< derived_t > | |
| k3d::vector4 | Encapsulates a direction vector in four-dimensional space |
| k3d::virtual_document_plugin_factory< interface_list > | |
| k3d::watched_path_property< value_t, name_policy_t > | |
| k3d::watched_path_serialization< value_t, property_policy_t > | Serialization policy for filesystem path data that handles external filesystem resources |
| k3d::xml::attribute | Encapsulates an XML attribute with name and value |
| k3d::xml::declaration | Inserts an XML declaration <?xml version="1.0" ?> into a stream |
| k3d::xml::detail::load_dependencies | |
| k3d::xml::detail::load_typed_array< arrays_t > | |
| k3d::xml::detail::same_name | Helper functor for searching for shaders by name |
| k3d::xml::detail::save_dependencies | |
| k3d::xml::detail::save_typed_array | |
| k3d::xml::element | Encapsulates an XML element with name, text, child attributes, and child elements |
| k3d::xml::hide_progress | Convenience implementation of the progress interface for use when feedback is not required (Null Object Pattern) |
| k3d::xml::progress | Abstract interface used to provide feedback during long parsing operations |
| k3d::xml::same_name | |
| k3d::xml::single_line | Iostream-compatible manipulator that controls whether subsequent XML will be serialized with-or-without line breaks |
| k3d::xml::xpath::grammar | |
| k3d::xml::xpath::grammar::definition< ScannerT > | |
| k3d::xml::xpath::match_absolute_path | |
| k3d::xml::xpath::match_attribute_name | |
| k3d::xml::xpath::match_attribute_value | |
| k3d::xml::xpath::match_child | |
| k3d::xml::xpath::match_context | |
| k3d::xml::xpath::match_root_path | |
| k3d::xml::xpath::match_wildcard | |
| k3d::yafray::ilight | Abstract interface for YafRay light sources |
| k3d::yafray::imaterial | Abstract interface for Yafray material objects |
| knots_t, immutable_name, change_signal, with_undo, local_storage, no_constraint, writable_property, array_serialization) | |
| string_t, immutable_name, change_signal, with_undo, local_storage, no_constraint, writable_property, with_serialization) | |
| string_t, no_name, change_signal, no_undo, local_storage, no_constraint, no_property, no_serialization) | |
| libk3drenderman::area_light | |
| libk3drenderman::array_1d | |
| libk3drenderman::array_2d | |
| libk3drenderman::array_3d | |
| libk3drenderman::csg_operator | Allows geometry to be rendered with boolean effects |
| libk3drenderman::csg_solid | |
| libk3drenderman::delayed_read_archive | |
| libk3drenderman::detail::setup_texture | |
| libk3drenderman::direct_texture_map | |
| libk3drenderman::displacement_shader | Implements a RenderMan displacement shader plugin |
| libk3drenderman::imager_shader | Implements a RenderMan imager shader plugin |
| libk3drenderman::lat_long_environment_map | |
| libk3drenderman::light | |
| libk3drenderman::light_shader | Implements a RenderMan light shader plugin |
| libk3drenderman::material | |
| libk3drenderman::read_archive | |
| libk3drenderman::render_engine | |
| libk3drenderman::render_engine::renderman_enabled_lights_property< value_t, name_policy_t > | Helper class that limits the list of enabled lights to those the implement k3d::ri::ilight |
| libk3drenderman::render_engine::renderman_visible_nodes_property< value_t, name_policy_t > | Helper class that limits the list of visible nodes to those that implement k3d::ri::irenderable |
| libk3drenderman::shadow_map | Implements the ShadowMap plugin, which is used to generate RenderMan shadow maps for fast rendering ////////////////////////////////////////////////////////////////////////// |
| libk3drenderman::surface_shader | Implements a RenderMan surface shader plugin |
| libk3drenderman::texture_map | |
| libk3drenderman::volume_shader | Implements a RenderMan volume shader plugin |
| light | |
| LPyramid | |
| module::animation::animation_track< time_t, value_t > | Encapsulates a series of keyframes |
| module::animation::animation_track_double_double | |
| module::animation::animation_track_double_matrix4 | |
| module::animation::delete_state_container< time_t, value_t > | State container that restores using a delete_key operation |
| module::animation::insufficient_data_exception | Thrown when the interpolator does not have enough key data to give an interpolation |
| module::animation::interpolator< time_t, value_t > | Base class for interpolation methods for keyframed animations |
| module::animation::interpolator_double_double_linear | |
| module::animation::interpolator_double_matrix4_linear | |
| module::animation::linear_interpolator< time_t, value_t > | Implement linear interpolation |
| module::animation::linear_interpolator< time_t, k3d::matrix4 > | Specialization with correct interpolation of angles |
| module::animation::store_state_container< time_t, value_t > | State container that restores using a "store keyframe" operation |
| module::animation::update_state_container< time_t, value_t > | State container that updates an existing key |
| module::annotation::annotate_normal | |
| module::annotation::annotation | |
| module::annotation::annotation_2d | |
| module::annotation::annotation_3d | |
| module::aqsis::display_manager | Custom Aqsis display manager that forwards display data using signals |
| module::aqsis::engine | |
| module::array::alternate_array_1d | |
| module::array::alternate_array_2d | |
| module::array::alternate_array_3d | |
| module::array::rotate_array_1d | |
| module::array::rotate_array_2d | |
| module::array::rotate_array_3d | |
| module::array::transform_array_1d | Boilerplate implementation of k3d::itransform_array_1d |
| module::array::transform_array_2d | Boilerplate implementation of k3d::itransform_array_1d |
| module::array::transform_array_3d | Boilerplate implementation of k3d::itransform_array_1d |
| module::array::translate_array_1d | |
| module::array::translate_array_2d | |
| module::array::translate_array_3d | |
| module::bicubic_patch::bicubic_to_poly | |
| module::bicubic_patch::newell_primitive | |
| module::bilinear_patch::poly_to_bilinear | |
| module::bitmap::add | |
| module::bitmap::add::functor | |
| module::bitmap::checker | |
| module::bitmap::color_monochrome | |
| module::bitmap::color_monochrome::functor | |
| module::bitmap::gamma | |
| module::bitmap::gamma::functor | |
| module::bitmap::invert | |
| module::bitmap::invert::functor | |
| module::bitmap::matte_colordiff | |
| module::bitmap::matte_colordiff::functor | |
| module::bitmap::matte_invert | |
| module::bitmap::matte_invert::functor | |
| module::bitmap::multiply | |
| module::bitmap::multiply::functor | |
| module::bitmap::reader | |
| module::bitmap::reference_image_2d | |
| module::bitmap::reference_image_3d | |
| module::bitmap::simple_modifier | |
| module::bitmap::solid | |
| module::bitmap::subtract | |
| module::bitmap::subtract::functor | |
| module::bitmap::threshold | |
| module::bitmap::threshold::functor | |
| module::blobby::add | |
| module::blobby::divide | |
| module::blobby::edges_to_blobby | |
| module::blobby::ellipsoid | |
| module::blobby::maximum | |
| module::blobby::minimum | |
| module::blobby::multiply | |
| module::blobby::negate | |
| module::blobby::points_to_blobby | |
| module::blobby::segment | |
| module::blobby::subtract | |
| module::carve::boolean | |
| module::carve::boolean::boolean_functor | |
| module::carve::detail::table_value | Stores attribute values at a single index |
| module::carve::detail::table_value::value_extractor | Extracts single values from a table, and puts them into the supplied map |
| module::cgal::boolean | |
| module::cgal::boolean::boolean_functor< nef_t > | |
| module::cgal::Construct_point_3_simplify< K > | Replacement for the standard point constructor that finds the GCD of 4 homogeneous coordinates and simplifies them |
| module::cgal::Construct_vector_3_simplify< K > | Replacement for the standard vector constructor that finds the GCD of 4 homogeneous coordinates and simplifies them |
| module::cgal::face_plane< kernel_t > | Returns the plane containing the face given to operator() |
| module::cgal::nef_visitor< nef_t > | Visitor class to help building the k3d mesh |
| module::cgal::point_converter< kernel_t > | Convert coordinates to the format of kernel_t |
| module::cgal::simplifying_kernel< RT_ > | Wrapper around the homogeneous kernel |
| module::cgal::simplifying_kernel_base< K_, K_Base > | Base for a kernel using these simplifying constructors |
| module::cgal::simplifying_kernel_base< K_, K_Base >::Base< Kernel2 > | |
| module::cloth::simulation | |
| module::collada::io::collada_obj | |
| module::collada::io::daeParser | |
| module::collada::io::document_exporter | |
| module::collada::io::document_importer | |
| module::collada::io::intCamera | |
| module::collada::io::intGeometry | |
| module::collada::io::intLight | |
| module::collada::io::mesh_reader | |
| module::collada::io::mesh_writer | |
| module::collada::io::Node | |
| module::compiz::compiz_check | |
| module::core::axes | Provides a configurable set of axes to assist users in visualizing the 3D workspace |
| module::core::camera | |
| module::core::camera::orthographic_projection | |
| module::core::camera::perspective_projection | |
| module::core::multi_material | |
| module::core::null | |
| module::cuda::cuda_bitmap_add | |
| module::cuda::cuda_bitmap_color_monochrome | |
| module::cuda::cuda_bitmap_gamma | |
| module::cuda::cuda_bitmap_invert | |
| module::cuda::cuda_bitmap_matte_colordiff | |
| module::cuda::cuda_bitmap_matte_invert | |
| module::cuda::cuda_bitmap_multiply | |
| module::cuda::cuda_bitmap_simple_modifier | |
| module::cuda::cuda_bitmap_subtract | |
| module::cuda::cuda_bitmap_threshold | |
| module::cuda::cuda_deformation_transform_points | |
| module::cuda::cuda_deformation_transform_points_asynchronous | |
| module::cuda::cuda_deformation_transform_points_device_mesh | |
| module::cuda::cuda_mesh_cuda_to_k3d_converter | |
| module::cuda::cuda_mesh_k3d_to_cuda_converter | |
| module::cuda::cuda_mesh_poly_grid | |
| module::cuda::cuda_mesh_poly_grid_and_transform | |
| module::cuda::cuda_mesh_subdivide_edges | |
| module::cuda::detail::varying_data_copier | Copies and interpolates the varying data as needed (serial usage only) |
| module::deformation::bend_points | |
| module::deformation::bend_points::bend | |
| module::deformation::bulge_points | |
| module::deformation::bulge_points::worker | |
| module::deformation::center_points | |
| module::deformation::cylindrical_wave_points | |
| module::deformation::deformation_expression | |
| module::deformation::linear_point_noise | |
| module::deformation::linear_transformation_worker | |
| module::deformation::linear_wave_points | |
| module::deformation::morph_points | |
| module::deformation::rotate_points | |
| module::deformation::scale_points | |
| module::deformation::shear_points | |
| module::deformation::smooth_points | |
| module::deformation::sphereize_points | |
| module::deformation::taper_points | |
| module::deformation::taper_points::worker | |
| module::deformation::transform_points | |
| module::deformation::translate_points | |
| module::deformation::tweak_points | |
| module::deformation::tweak_points::tweaks_container | |
| module::deformation::twist_points | |
| module::deformation::twist_points::worker | |
| module::development::glsl_painter | |
| module::euler::kill_edge_and_vertex | |
| module::euler::kill_edge_make_loop | |
| module::f3ds::io::f3dsParser | |
| module::f3ds::io::mesh_reader | |
| module::file::magic::mime_type_handler | Uses a hard-coded list of file extensions to identify MIME types |
| module::freetype2::detail::freetype_outline | Adds a freetype glyph outline to a k3d::polyhedron::primitive |
| module::freetype2::face | Encapsulates the freetype FT_Face struct to provide RAII behavior |
| module::freetype2::library | Encapsulates the freetype FT_Library struct to provide RAII behavior |
| module::freetype2::poly_text | |
| module::gl::virtual_painters::virtual_edge_painter_factory | |
| module::gl::virtual_painters::virtual_face_painter_factory | |
| module::gl::virtual_painters::virtual_point_painter_factory | |
| module::gl::virtual_painters::virtual_sds_edge_painter_factory | |
| module::gl::virtual_painters::virtual_sds_face_painter_factory | |
| module::gl::virtual_painters::virtual_sds_point_painter_factory | |
| module::glx::api_loader | |
| module::glx::context | |
| module::glx::context_factory | |
| module::gnome::mime_type_handler | Uses the Gnome API to identify MIME types |
| module::gnome::uri_handler | Uses the Gnome API to open a URI in the user's preferred application |
| module::google_perftools::google_perftools | |
| module::graphviz::mesh_writer | |
| module::graphviz::render_engine | |
| module::gts::detail::triangulator | Converts a k3d::mesh to a GtsSurface as it is triangulated |
| module::gts::gts_ptr< T > | Smart pointer for holding GTS objects |
| module::gts::io::mesh_reader | |
| module::gts::mesh_area | |
| module::gts::mesh_volume | |
| module::highlighting::rubber_band | |
| module::imagemagick::io::bitmap_importer | Reads a wide variety of image file formats using the ImageMagick C++ bindings |
| module::indigo::background | |
| module::indigo::diffuse_material | |
| module::indigo::light | Used to "flag" Indigo light objects |
| module::indigo::material | Used to "flag" Indigo material objects |
| module::indigo::rectangle_light | |
| module::indigo::render_engine | |
| module::indigo::render_engine::create_triangles | Helper class used to triangulate faces |
| module::indigo::render_engine::indigo_enabled_lights_property< value_t, name_policy_t > | Helper class that limits the list of enabled lights |
| module::indigo::render_engine::indigo_visible_nodes_property< value_t, name_policy_t > | Helper class that limits the list of visible nodes to those that we can render |
| module::indigo::skylight | |
| module::indigo::spectrum | Provides property storage and rendering for an Indigo "spectrum" tag |
| module::inotify::file_change_notifier | |
| module::jpeg::io::bitmap_importer | |
| module::jpeg::io::bitmap_reader | |
| module::jpeg::io::bitmap_writer | |
| module::jpeg::io::bitmap_writer::extract_rgb | |
| module::k3d_io::document_exporter | Serializes a K-3D document using the native K-3D XML format |
| module::k3d_io::document_importer | |
| module::k3d_io::mesh_reader | |
| module::k3d_io::mesh_writer | |
| module::k3d_io::set_default_material | |
| module::linear_curve::knot_curve | |
| module::linear_curve::lissajous_curve | |
| module::lsystem::l_parser | |
| module::lsystem::lparser::context | |
| module::lsystem::lparser::polygon | |
| module::lsystem::lparser::s_rec | |
| module::luxrender::bilinear_interpolation_texture | |
| module::luxrender::carpaint_material | |
| module::luxrender::color_texture | Abstract interface for LuxRender color texture nodes |
| module::luxrender::color_texture_reference | Wraps a set of K-3D properties for use as a LuxRender color texture |
| module::luxrender::distant_light | |
| module::luxrender::environment_light | |
| module::luxrender::glass_material | |
| module::luxrender::glossy_material | |
| module::luxrender::goniometric_light | |
| module::luxrender::image_texture | |
| module::luxrender::light | Abstract interface for LuxRender light nodes |
| module::luxrender::material | Abstract interface for LuxRender material nodes |
| module::luxrender::matte_material | |
| module::luxrender::matte_translucent_material | |
| module::luxrender::metal_material | |
| module::luxrender::mirror_material | |
| module::luxrender::mix_material | |
| module::luxrender::null_material | |
| module::luxrender::point_light | |
| module::luxrender::render_engine | |
| module::luxrender::render_engine::create_triangles | Helper class used to triangulate faces |
| module::luxrender::render_engine::luxrender_enabled_lights_property< value_t, name_policy_t > | Helper class that limits the list of enabled lights |
| module::luxrender::render_engine::luxrender_visible_nodes_property< value_t, name_policy_t > | Helper class that limits the list of visible nodes to those that we can render |
| module::luxrender::rough_glass_material | |
| module::luxrender::scalar_image_texture | |
| module::luxrender::scalar_texture | Abstract interface for LuxRender float texture nodes |
| module::luxrender::scalar_texture_reference | Wraps a set of K-3D properties for use as a LuxRender color texture |
| module::luxrender::shiny_metal_material | |
| module::luxrender::sky_light | |
| module::luxrender::sun_light | |
| module::luxrender::texture | Abstract interface for LuxRender texture objects |
| module::luxrender::texture2 | Abstract base class for LuxRender 2D texture objects |
| module::matrix::frozen_matrix | |
| module::matrix::inverse | |
| module::matrix::look | |
| module::matrix::orientation | |
| module::matrix::position | |
| module::matrix::scale | |
| module::matrix::snap | |
| module::matrix::view | |
| module::md2::io::md2Frames | |
| module::md2::io::md2Header | |
| module::md2::io::md2Model | |
| module::md2::io::md2SingleFrame | |
| module::md2::io::md2TexCoords | |
| module::md2::io::md2TmpTexCoords | |
| module::md2::io::md2Triangles | |
| module::md2::io::md2TriangleVertex | |
| module::md2::io::md2Vertex | |
| module::md2::io::mesh_reader_implementation | |
| module::mesh::array_1d_implementation | |
| module::mesh::array_2d_implementation | |
| module::mesh::array_3d_implementation | |
| module::mesh::merge_mesh | |
| module::mesh::points_centroid | |
| module::mesh::weld_points | |
| module::mesh::weld_points::map_point_indices | |
| module::mesh_attributes::calculate_normals | |
| module::mesh_attributes::named_text_array | |
| module::mesh_attributes::set_color | |
| module::mesh_attributes::set_material | |
| module::mesh_instance::frozen_mesh | |
| module::mesh_instance::mesh_instance | |
| module::ngui::about::dialog | Creates an "about" box that displays program version and copyright |
| module::ngui::animation_timeline::detail::implementation | |
| module::ngui::animation_timeline::detail::timeline | Custom timeline widget |
| module::ngui::animation_timeline::panel | |
| module::ngui::assign_hotkeys::dialog | |
| module::ngui::assign_hotkeys::dialog::plugin_factory | Provides a custom plugin factory for creating assign_hotkeys::dialog instances |
| module::ngui::atk_event_recorder::dialog | |
| module::ngui::file_notification | |
| module::ngui::file_notification::implementation | |
| module::ngui::knot_vector::control | Provides a custom property-control for NURBS knot-vectors |
| module::ngui::knot_vector::control::knot_vector_model | Implementation of entry::imodel for use with knot vectors |
| module::ngui::learning::dialog | Provides a menu of demonstration documents |
| module::ngui::learning::dialog::resource_columns | |
| module::ngui::learning::dialog::test_examples | |
| module::ngui::log::dialog | Provides a window for viewing the contents of the K-3D log |
| module::ngui::material_manager::mechanics::ContentPanel | |
| module::ngui::material_manager::mechanics::GroupContentPanel | |
| module::ngui::material_manager::mechanics::Implementation | |
| module::ngui::material_manager::mechanics::Implementation::columns | |
| module::ngui::material_manager::mechanics::MaterialContentPanel | |
| module::ngui::material_manager::mechanics::MaterialGroup | |
| module::ngui::material_manager::mechanics::MaterialObj | |
| module::ngui::material_manager::mechanics::Model | |
| module::ngui::material_manager::mechanics::PreviewCube | |
| module::ngui::material_manager::mechanics::PreviewObj | |
| module::ngui::material_manager::mechanics::PreviewSphere | |
| module::ngui::material_manager::mechanics::PreviewTorus | |
| module::ngui::material_manager::mechanics::RenderedImage | |
| module::ngui::material_manager::Panel | |
| module::ngui::mesh::control | Provides a custom property-control for NURBS knot-vectors |
| module::ngui::morph_points::page | Provides a custom plugin-page for the MorphPoints modifier |
| module::ngui::node_list::panel | |
| module::ngui::node_list::panel::columns | |
| module::ngui::node_properties::detail::implementation | |
| module::ngui::node_properties::panel | |
| module::ngui::opengl::dialog | Creates an "about" box that displays program version and copyright |
| module::ngui::parent::implementation | |
| module::ngui::parent::tool | User-interface tool that provides interactive node parenting |
| module::ngui::pipeline::detail::drawing_area | Drawing area widget that emits a signal when it needs to be redrawn |
| module::ngui::pipeline::detail::extract_tree_visitor | BFS visitor class that marks vertices and edges for extraction from a graph |
| module::ngui::pipeline::document_to_graph | Converts a K-3D document to an undirected graph |
| module::ngui::pipeline::edge_indices | Graph_modifier implementation that computes the index for every edge in a graph |
| module::ngui::pipeline::extract_tree | |
| module::ngui::pipeline::panel | |
| module::ngui::pipeline::tree_layout | |
| module::ngui::pipeline::tree_layout::coordinate_visitor | BFS visitor class that computes rank and item for each node in a tree |
| module::ngui::pipeline_profiler::panel | |
| module::ngui::pipeline_profiler::panel::columns | |
| module::ngui::pipeline_profiler::panel::new_record | |
| module::ngui::python_shell::dialog | Provides an interactive Python shell dialog |
| module::ngui::rectangle::control | Provides a control for k3d::rectangle properties |
| module::ngui::rectangle::spin_button_model | Adapts a spin button to control a single rectangle value |
| module::ngui::render_region::implementation | |
| module::ngui::render_region::tool | User-interface tool that provides interactive controls for cropped rendering |
| module::ngui::selection::control | Provides a custom control for k3d::selection::set properties |
| module::ngui::snap::detail::abstract_tool | |
| module::ngui::snap::snap_tool_detail | |
| module::ngui::snap::snap_tool_detail::itarget | Stores an object to be moved interactively |
| module::ngui::snap::snap_tool_detail::mesh_target | |
| module::ngui::snap::snap_tool_detail::transform_target | |
| module::ngui::snap::tool | Interactive tool that provides "snappable" transformations for objects |
| module::ngui::snap::tool::implementation | |
| module::ngui::snap::tool::implementation::constraint | |
| module::ngui::space_navigator::dialog | |
| module::ngui::space_navigator::events | Encapsulates threaded asynchronous handling of SpaceNavigator hardware events |
| module::ngui::splash_box | Creates a modal "splash" box that displays program version and copyright |
| module::ngui::text_editor::dialog | |
| module::ngui::timeline::detail::implementation | |
| module::ngui::timeline::panel | |
| module::ngui::tool_properties::detail::implementation | |
| module::ngui::tool_properties::panel | |
| module::ngui::toolbar::detail::builtin_tool_model | |
| module::ngui::toolbar::detail::convert_selection_model | Provides an implementation of k3d::toggle_button::imodel for visualizing the current convert selection mode |
| module::ngui::toolbar::detail::implementation | |
| module::ngui::toolbar::detail::keep_selection_model | Provides an implementation of k3d::toggle_button::imodel for visualizing the current keep selection mode |
| module::ngui::toolbar::detail::plugin_tool_model | Provides an implementation of k3d::toggle_button::imodel for visualizing the active tool |
| module::ngui::toolbar::detail::selection_mode_model | Provides an implementation of k3d::toggle_button::imodel for visualizing the current selection mode |
| module::ngui::toolbar::panel | |
| module::ngui::undo_tree::detail::implementation | |
| module::ngui::undo_tree::detail::implementation::columns | Declares columns for the TreeView data model |
| module::ngui::undo_tree::panel | |
| module::ngui::user_interface | |
| module::ngui::uveditor::detail::uv_set_model | |
| module::ngui::uveditor::panel | |
| module::nui::user_interface | Provides the Null User Interface, a do-nothing user interface plugin useful for executing scripts and as a starting-point for user interface authors |
| module::nurbs::add_trim_curve | |
| module::nurbs::close_curve | |
| module::nurbs::close_curve::curve_closer | |
| module::nurbs::connect_curves | |
| module::nurbs::create_cap | |
| module::nurbs::curve_arrays | Convenient storage for all components and attributes of a single curve |
| module::nurbs::curve_arrays::curve_value | Encapsulates the complete evaluation of position, weight and attributes for a certain parameter value |
| module::nurbs::curve_copier | Copy structure and attributes between curves |
| module::nurbs::curve_degree_elevation | |
| module::nurbs::curve_degree_elevation::degree_elevator | |
| module::nurbs::curve_point_data_copier | Copy from curve data to patch data |
| module::nurbs::curve_traversal | |
| module::nurbs::degree_elevator | Applies NURBS curve degree elevation to reach the given order |
| module::nurbs::detail::inf_norm | |
| module::nurbs::edit_knot_vector | |
| module::nurbs::extract_curve_point | |
| module::nurbs::extract_curve_point::curve_point_extractor | |
| module::nurbs::extract_patch_curve | |
| module::nurbs::extract_trim_curves | |
| module::nurbs::extrude_curve | |
| module::nurbs::extrude_patch | |
| module::nurbs::find_first_knot_after | Predicate to find the first knot greater than the value given in the constructor |
| module::nurbs::find_knot_multiplicity | Predicate to find knot multiplicity |
| module::nurbs::flip_curve | |
| module::nurbs::insert_knot | |
| module::nurbs::insert_knot::knot_inserter | |
| module::nurbs::knot_normalizer | Use with std::transform to normalize a knot vector |
| module::nurbs::knot_vector_calculator | Calculates a common knot vector among the visited curves |
| module::nurbs::knot_vector_merger | Makes UnifiedKnots the knot vector of all given curves |
| module::nurbs::max_order_calculator | Calculates the maximum order of all visited curves |
| module::nurbs::merge_connected_curves | |
| module::nurbs::merge_curve_knot_vectors | |
| module::nurbs::patch_attribute_tables | Extract and store patch and parameter attributes for a single patch |
| module::nurbs::patch_degree_elevation | |
| module::nurbs::patch_degree_elevation::degree_elevator | |
| module::nurbs::patch_insert_knot | |
| module::nurbs::patch_insert_knot::knot_inserter | |
| module::nurbs::patch_point_data | Encapsulates the control point positions, weights and attributes for a single patch |
| module::nurbs::point_data_copier | Copy structure and attributes between patch point data structures |
| module::nurbs::polygonize_curve | |
| module::nurbs::polygonize_curve::curve_polygonizer | |
| module::nurbs::polygonize_patch | |
| module::nurbs::revolve_curve | |
| module::nurbs::ruled_surface | |
| module::nurbs::selected_component_extractor | Visitor to get the selected components |
| module::nurbs::selected_curve_extractor | |
| module::nurbs::set_weight | |
| module::nurbs::skinned_surface | |
| module::nurbs::source::circle | |
| module::nurbs::source::cone | |
| module::nurbs::source::curve | |
| module::nurbs::source::cylinder | |
| module::nurbs::source::disk | |
| module::nurbs::source::grid | |
| module::nurbs::source::hyperboloid | |
| module::nurbs::source::paraboloid | |
| module::nurbs::source::polygon | |
| module::nurbs::source::sphere | |
| module::nurbs::source::torus | |
| module::nurbs::split_curve | |
| module::nurbs::split_curve::curve_splitter | |
| module::nurbs::split_patch | |
| module::nurbs::split_patch::patch_splitter | |
| module::nurbs::sweep_surface | |
| module::nurbs::sweep_surface::curve_extractor | Extracts the first curve as a path, and the rest as curves that sweep it |
| module::obj::io::mesh_reader | |
| module::obj::io::mesh_reader::my_parser | Implementation of obj_parser that instantiates just points and faces to start .. |
| module::obj::io::mesh_writer | |
| module::obj::io::obj_parser | Template design pattern class for parsing Wavefront (.obj) files |
| module::obj::io::print_obj | Concrete implementation of obj_parser that does pretty-printing of the file contents for debugging |
| module::ode::isimulation | |
| module::ode::node | |
| module::ode::simulation | |
| module::ogre::io::mesh_writer | |
| module::opencascade::detail::implementation | |
| module::opencascade::opencascade_document_importer | |
| module::opencascade::opencascade_document_processor | Processes all nodes of an OpenCascade document |
| module::opencascade::opencascade_mesh_reader_implementation | |
| module::openexr::io::bitmap_importer | |
| module::opengl::detail::draw | Functor for drawing objects during OpenGL drawing |
| module::opengl::detail::draw_selection | Functor for selecting objects during OpenGL drawing |
| module::opengl::detail::light_setup | Functor object for initializing light sources during OpenGL drawing |
| module::opengl::detail::render_order | |
| module::opengl::painters::bezier_triangle_patch_painter | |
| module::opengl::painters::bicubic_patch_painter | |
| module::opengl::painters::bilinear_patch_painter | |
| module::opengl::painters::blobby_point_painter | |
| module::opengl::painters::cached_polyhedron_data< key_t, data_t > | Boilerplate implementation for hint processing |
| module::opengl::painters::cached_triangulation | |
| module::opengl::painters::color_face_painter | |
| module::opengl::painters::color_face_painter::color_array_proxy | |
| module::opengl::painters::colored_selection_painter | |
| module::opengl::painters::component_selection | Keep track of component selections |
| module::opengl::painters::cone_painter | |
| module::opengl::painters::cubic_curve_painter | |
| module::opengl::painters::cylinder_painter | |
| module::opengl::painters::detail::face_normals | |
| module::opengl::painters::detail::point_normals | |
| module::opengl::painters::disk_painter | |
| module::opengl::painters::edge_numbering_painter | |
| module::opengl::painters::edge_painter | |
| module::opengl::painters::edge_selection | Implement component_selection::on_execute for an edge selection |
| module::opengl::painters::edge_vbo | Keep track of edge indices in a VBO |
| module::opengl::painters::edge_visitor | Stores SDS patch border data in OpenGL-compatible arrays |
| module::opengl::painters::face_normal_painter | |
| module::opengl::painters::face_numbering_painter | |
| module::opengl::painters::face_orientation_painter | |
| module::opengl::painters::face_painter | |
| module::opengl::painters::face_painter::paint_triangles | |
| module::opengl::painters::face_painter::select_triangles | |
| module::opengl::painters::face_selection | Implement component_selection::on_execute for a face selection |
| module::opengl::painters::face_varying_painter | |
| module::opengl::painters::face_visitor | Stores SDS face data in OpenGL-compatible arrays |
| module::opengl::painters::face_visitor_no_boundary | |
| module::opengl::painters::half_edge_painter | |
| module::opengl::painters::hidden_line_painter | |
| module::opengl::painters::hyperboloid_painter | |
| module::opengl::painters::linear_curve_painter | |
| module::opengl::painters::multi_painter | |
| module::opengl::painters::normal_array_painter | |
| module::opengl::painters::normal_cache | |
| module::opengl::painters::nurbs_curve_numbering_painter | |
| module::opengl::painters::nurbs_curve_painter | |
| module::opengl::painters::nurbs_patch_numbering_painter | |
| module::opengl::painters::nurbs_patch_painter | |
| module::opengl::painters::painter_cache< key_t, data_t > | Stores cached data that can be shared between mesh painters |
| module::opengl::painters::painter_cache< key_t, data_t >::lru_stack | A custom stack, where items are unique |
| module::opengl::painters::painter_cache< key_t, data_t >::lru_stack::stackitem | |
| module::opengl::painters::paraboloid_painter | |
| module::opengl::painters::point_data | |
| module::opengl::painters::point_normal_painter | |
| module::opengl::painters::point_numbering_painter | |
| module::opengl::painters::point_painter | |
| module::opengl::painters::point_selection | Point selection |
| module::opengl::painters::point_vbo | Keep track of point position data in a VBO |
| module::opengl::painters::point_visitor | Stores SDS patch corner data in OpenGL-compatible arrays |
| module::opengl::painters::sds_cache | Common SDS cache functionality |
| module::opengl::painters::sds_edge_painter | |
| module::opengl::painters::sds_edge_painter::painting_visitor | |
| module::opengl::painters::sds_edge_painter::selecting_visitor | |
| module::opengl::painters::sds_edge_vbo | Cache SDS edge VBOs |
| module::opengl::painters::sds_face_painter | |
| module::opengl::painters::sds_face_painter::painting_visitor | |
| module::opengl::painters::sds_face_painter::selecting_visitor | |
| module::opengl::painters::sds_face_vbo | Cache SDS face VBOs |
| module::opengl::painters::sds_painter< selection_t > | |
| module::opengl::painters::sds_point_painter | |
| module::opengl::painters::sds_point_painter::painting_visitor | |
| module::opengl::painters::sds_point_painter::selecting_visitor | |
| module::opengl::painters::sds_point_vbo | Cache SDS point VBOs |
| module::opengl::painters::sds_vbo< component_t > | Keep track of the SDS VBOs per level |
| module::opengl::painters::sphere_painter | |
| module::opengl::painters::teapot_painter | |
| module::opengl::painters::texture_colored_selection_painter | |
| module::opengl::painters::textured_face_painter | |
| module::opengl::painters::torus_painter | |
| module::opengl::painters::triangle_vbo | VBOs used to paint a triangulated mesh |
| module::opengl::painters::update_edge_vbo_visitor | Helper class to update the point VBO |
| module::opengl::painters::update_face_vbo_visitor | Helper class to update the point VBO |
| module::opengl::painters::update_face_vbo_visitor_no_boundary | Helper class to update the point VBO when interpolateboundary is not set |
| module::opengl::painters::update_point_vbo_visitor | Helper class to update the point VBO |
| module::opengl::painters::varying_data_painter | |
| module::opengl::painters::vbo | Convenience wrapper for OpenGL vertex buffer objects |
| module::opengl::painters::vbo_edge_painter | |
| module::opengl::painters::vbo_exception | Exception for VBO-related errors |
| module::opengl::painters::vbo_face_painter | |
| module::opengl::painters::vbo_point_painter | |
| module::opengl::painters::vbo_sds_edge_painter | |
| module::opengl::painters::vbo_sds_face_painter | |
| module::opengl::painters::vbo_sds_painter< selection_t, vbo_t > | |
| module::opengl::painters::vbo_sds_point_painter | |
| module::opengl::painters::vertex_data_painter | |
| module::opengl::render_engine | |
| module::opengl::version_check | |
| module::osmesa::api_loader | |
| module::osmesa::context | |
| module::osmesa::context_factory | |
| module::osx::uri_handler | Uses the Mac OSX API to open a URI in the user's preferred application |
| module::papagayo_lipsync_reader::detail::papagayo_lipsync_reader_implementation | |
| module::papagayo_lipsync_reader::papagayo_lipsync_reader | Reads a papagayo .dat file and outputs the values for morphing |
| module::particle::points_to_particles | |
| module::pdiff::perceptual_difference | Computes the a difference metric between two images based on the physiology of human vision |
| module::pixie::raytrace_map | |
| module::plot::detail::least_squares_solver_plotter | |
| module::plot::least_squares_plot | |
| module::plot::surface_plot | |
| module::ply::io::mesh_reader | |
| module::ply::io::mesh_writer | |
| module::ply::io::mesh_writer::triangulator | |
| module::png::io::bitmap_importer | |
| module::png::io::bitmap_reader | |
| module::png::io::bitmap_writer | |
| module::polyhedron::bevel_faces_implementation | |
| module::polyhedron::bevel_points | |
| module::polyhedron::bevel_points::bevel_corner | Caches polyhedron "corners" that are to be bevelled |
| module::polyhedron::bevel_points::bevel_vertex | Caches new points for better interactive performance |
| module::polyhedron::bridge_edges | |
| module::polyhedron::bridge_edges::adjacency_edge | |
| module::polyhedron::bridge_faces | |
| module::polyhedron::cap_holes | |
| module::polyhedron::collapse_edges | |
| module::polyhedron::collapse_faces | |
| module::polyhedron::collapse_points | |
| module::polyhedron::connect_vertices | |
| module::polyhedron::delete_components | |
| module::polyhedron::detail::bevel_edge | Caches new geometry for better interactive performance |
| module::polyhedron::detail::border_info_t | |
| module::polyhedron::detail::border_point | |
| module::polyhedron::detail::border_t | |
| module::polyhedron::detail::face_point | |
| module::polyhedron::detail::get_edges | Functor that gets selected edges |
| module::polyhedron::dissolve_faces | |
| module::polyhedron::dissolve_faces::adjacency_edge | |
| module::polyhedron::extrude_faces | |
| module::polyhedron::extrude_faces::extrude_vertex | Caches new points for better interactive performance |
| module::polyhedron::fillet_edges_implementation | |
| module::polyhedron::flip_orientation_implementation | |
| module::polyhedron::make_sds_implementation | |
| module::polyhedron::merge_collinear_edges | |
| module::polyhedron::merge_coplanar_faces | |
| module::polyhedron::move_first_edge_implementation | |
| module::polyhedron::sds_corner | |
| module::polyhedron::sds_crease | |
| module::polyhedron::sds_hole | |
| module::polyhedron::selected_faces_to_polyhedron | |
| module::polyhedron::sources::poly_cone | |
| module::polyhedron::sources::poly_cube | |
| module::polyhedron::sources::poly_cushion | |
| module::polyhedron::sources::poly_cylinder | |
| module::polyhedron::sources::poly_disk | |
| module::polyhedron::sources::poly_grid | |
| module::polyhedron::sources::poly_icosahedron | |
| module::polyhedron::sources::poly_sphere | |
| module::polyhedron::sources::poly_torus | |
| module::polyhedron::subdivide_edges | |
| module::polyhedron::subdivide_faces | |
| module::polyhedron::triangulate_faces | |
| module::python::engine | |
| module::python::initialize_python | Ensures that Py_Initialize() is called before any other Python API functions |
| module::pyui::user_interface | Provides an interactive python shell user interface to K-3D, useful for prototyping and executing scripts when a graphical UI isn't needed |
| module::qslim::qslim | |
| module::qslim::qslim::qslim_convert | |
| module::qtui::about::dialog | Creates an "about" box that displays program version and copyright |
| module::qtui::aqsis::dialog | Displays output from an embedded Aqsis render engine |
| module::qtui::aqsis::mode | Sets-up a default mode for use when no other mode is in-effect |
| module::qtui::aqsis::thread | |
| module::qtui::boolean::widget | Provides a widget for k3d::bool_t properties |
| module::qtui::color::widget | Provides a widget for k3d::bool_t properties |
| module::qtui::def::mode | Sets-up a default mode for use when no other mode is in-effect |
| module::qtui::javascript::shell | |
| module::qtui::log::window | |
| module::qtui::main_window | |
| module::qtui::matrix::dialog | Provides a dialog for k3d::matrix4 properties |
| module::qtui::matrix::widget | Provides a widget for k3d::bool_t properties |
| module::qtui::node_list::panel | |
| module::qtui::node_properties::panel | |
| module::qtui::opengl::window | Displays output from an embedded Aqsis render engine |
| module::qtui::path::widget | Provides a widget for k3d::bool_t properties |
| module::qtui::programmable::mode | Provides a programmable edit mode, mainly intended for development |
| module::qtui::scene | |
| module::qtui::string::widget | Provides a widget for k3d::bool_t properties |
| module::qtui::text_editor::window | |
| module::qtui::user_interface | Implements the Qt User Interface plugin |
| module::qtui::viewport | |
| module::quadrics::cone | |
| module::quadrics::cylinder | |
| module::quadrics::disk | |
| module::quadrics::hyperboloid | |
| module::quadrics::logo | |
| module::quadrics::paraboloid | |
| module::quadrics::quadric | |
| module::quadrics::sphere | |
| module::quadrics::teapot | |
| module::quadrics::torus | |
| module::release::welcome | |
| module::renderman::engine::air | |
| module::renderman::engine::aqsis | |
| module::renderman::engine::bmrt | |
| module::renderman::engine::bundled::aqsis | |
| module::renderman::engine::delight | |
| module::renderman::engine::netprman | |
| module::renderman::engine::pixie | |
| module::renderman::engine::povman | |
| module::renderman::engine::prman | |
| module::renderman::engine::rdc | |
| module::renderman::painters::array_copier | Makes an internal copy of a set of named mesh arrays |
| module::renderman::painters::array_copier::implementation | |
| module::renderman::painters::array_copier::implementation::copier< array_type > | |
| module::renderman::painters::array_copier::implementation::copier_interface | |
| module::renderman::painters::bicubic_patch_painter | |
| module::renderman::painters::bilinear_patch_painter | |
| module::renderman::painters::blobby_painter | |
| module::renderman::painters::cone_painter | |
| module::renderman::painters::cubic_curve_painter | |
| module::renderman::painters::cylinder_painter | |
| module::renderman::painters::disk_painter | |
| module::renderman::painters::hyperboloid_painter | |
| module::renderman::painters::linear_curve_painter | |
| module::renderman::painters::multi_painter | |
| module::renderman::painters::nurbs_patch_painter | |
| module::renderman::painters::paraboloid_painter | |
| module::renderman::painters::particle_painter | |
| module::renderman::painters::polyhedron_painter | |
| module::renderman::painters::scripted_painter | |
| module::renderman::painters::sphere_painter | |
| module::renderman::painters::subdivision_surface_painter | |
| module::renderman::painters::teapot_painter | |
| module::renderman::painters::torus_painter | |
| module::sample::plugin | |
| module::scalar::add | Takes two doubles as input and produce their sum as output |
| module::scalar::divide | An object that take two doubles as input and produce their quotient as output |
| module::scalar::double_to_string | |
| module::scalar::expression | |
| module::scalar::modulo | An object that take two doubles as input and produce their remainder as output |
| module::scalar::multiply | An object that take two doubles as input and produce their product as output |
| module::scalar::sine | Applies the sine() operator to input value |
| module::scalar::subtract | An object that take two doubles as input and produce their difference as output |
| module::scripted_plugins::application_factory | K3d::iapplication_plugin_factory implementation that creates a scripted plugin instance |
| module::scripted_plugins::document_factory | K3d::idocument_plugin_factory implementation that creates a scripted document node |
| module::scripting::action_script | |
| module::scripting::bitmap_modifier_script | |
| module::scripting::bitmap_source_script | |
| module::scripting::color_source_script | |
| module::scripting::double_source_script | |
| module::scripting::int32_source_script | |
| module::scripting::matrix_modifier_script | |
| module::scripting::matrix_source_script | |
| module::scripting::mesh_modifier_script | |
| module::scripting::mesh_source_script | |
| module::scripting::meta_object_script | |
| module::scripting::null_output_script | |
| module::scripting::opengl_painter_script | |
| module::scripting::opengl_renderable_script | |
| module::scripting::render_engine_script | |
| module::scripting::string_source_script | |
| module::scripting::vector3_source_script | |
| module::selection::face_to_point_selections | |
| module::selection::grow_selection | |
| module::selection::make_curve_selection | |
| module::selection::make_edge_selection | |
| module::selection::make_face_selection | |
| module::selection::make_patch_selection | |
| module::selection::make_point_selection | |
| module::selection::mesh_selection | |
| module::selection::node_selection | |
| module::selection::node_selection::selection_weight_serialization< value_t, property_policy_t > | |
| module::selection::select_bicubic_patch_by_number | |
| module::selection::select_bilinear_patch_by_number | |
| module::selection::select_boundary_edges | |
| module::selection::select_clockwise | |
| module::selection::select_companion | |
| module::selection::select_connected_components | |
| module::selection::select_connected_components::connected_faces_selector | Recurse through faces, selecting all connected faces |
| module::selection::select_cube | |
| module::selection::select_cubic_curve_by_number | |
| module::selection::select_degenerate_faces | |
| module::selection::select_edge_by_number | |
| module::selection::select_edge_loops | |
| module::selection::select_edge_rings | |
| module::selection::select_face_by_number | |
| module::selection::select_linear_curve_by_number | |
| module::selection::select_n_sided | |
| module::selection::select_nurbs_curve_by_number | |
| module::selection::select_nurbs_patch_by_number | |
| module::selection::select_point_by_number | |
| module::solar::position | |
| module::stl::io::binary_stl | Encapsulates the STL binary data format |
| module::stl::io::facet | Binary encapsulation of a single facet |
| module::stl::io::mesh_reader | |
| module::stl::io::mesh_writer | |
| module::stl::io::mesh_writer::triangulator | |
| module::subdivision_surface::catmull_clark_subdivider | |
| module::svg::io::mesh_reader | |
| module::test::add_color_attribute | |
| module::test::add_color_attributes | |
| module::test::add_index_attributes | |
| module::test::add_point_attributes | |
| module::test::mesh_to_stdout | |
| module::test::pipeline_profiler | |
| module::test::selection_to_stdout | |
| module::test::string_to_stdout | |
| module::test::valid_meshes | |
| module::tiff::io::bitmap_exporter | |
| module::tiff::io::bitmap_importer | |
| module::tiff::io::bitmap_reader | |
| module::tiff::io::bitmap_writer | |
| module::tiff::io::bitmap_writer::extract_rgb | |
| module::time::manual_time_source | |
| module::time::real_time_source | |
| module::time::time_source | |
| module::time::time_to_string | |
| module::uniform_polyhedron::uniform_polyhedron | |
| module::virtual_offscreen::virtual_camera_to_bitmap_factory | |
| module::wgl::camera_to_bitmap | |
| module::wgl::CGLBitmapContext | |
| module::windows::disable_desktop_composition | |
| module::windows::uri_handler | Uses the Win32 API to open a URI in the user's preferred application |
| module::xtrackcad::document_importer | |
| module::yafray::area_light | |
| module::yafray::colored_light< base_t > | |
| module::yafray::global_photon_light | |
| module::yafray::hemi_light | |
| module::yafray::light< base_t > | |
| module::yafray::material | |
| module::yafray::optional_shadows< base_t > | |
| module::yafray::photon_light | |
| module::yafray::photons< base_t > | |
| module::yafray::point_light | |
| module::yafray::render_engine | |
| module::yafray::render_engine::create_triangles | Helper class used to triangulate faces for Yafray |
| module::yafray::render_engine::yafray_enabled_lights_property< value_t, name_policy_t > | Helper class that limits the list of enabled lights to those the implement k3d::yafray::ilight |
| module::yafray::render_engine::yafray_visible_nodes_property< value_t, name_policy_t > | Helper class that limits the list of visible nodes to those that we can render |
| module::yafray::renderable_light< base_t > | |
| module::yafray::soft_light | |
| module::yafray::spot_light | |
| module::yafray::sun_light | |
| optional_shadows | |
| Particle | |
| posdata | |
| PQhandleElem | |
| PQnode | |
| PriorityQ | |
| quoted_string | |
| RGBAImage | |
| SGItesselator | |
| vector | |
| stuff | |
| testing::timer | |
| timingInfo_t | |
| trigdata | |
