<> {{{#!wiki red/solid Development on this stack is discontinued. }}} == Documentation == The `visualization_engine` stack (also known as `RVE`) is a framework for developing 3D visualization tools. The goal of `RVE` is to provide enough functionality to build `rviz2` as a GUI on top of it. While the overall goal of the stack is 3D visualization, there are also a number of underlying technologies that have been developed that may be useful on their own. These packages are currently prefixed by `rve_`, but if they're proven useful may get promoted upwards. The packages in `RVE` can be thought of as belonging to 4 different categories. There are '''infrastructure''' packages, which may be useful outside of `RVE`. Second, there are message/interface packages, which provide messages that are specific to `RVE`. Third, there are '''rendering''' packages, which handle the various aspects of 3D rendering. Last, there are '''meta-visualization''' packages, which provide higher-level functionality on top of the infrastructure and rendering packages. === Infrastructure === These packages may be useful outside of `RVE`, and may be promoted to a higher level at some point. They're being released under the `RVE` name in order to prove their use and evolve their APIs under real-world use. They also tend to make assumptions about how they're being used that will need to be fixed before they can be promoted out of `RVE`. Note that anything here that says it's cross-platform really means it has been abstracted so that alternate platforms can be easily implemented. The only currently tested platform is posix. * [[rve_common]] contains some useful classes/utilities. The main piece that could be promoted is the `UUID` class, which provides a cross-platform [[http://en.wikipedia.org/wiki/Universally_unique_identifier|UUID]] class. * [[rve_dynlib]] provides a cross-platform low-level dynamic loading interface. * [[rve_pluginloader]] provides a plugin-loading interface originally derived from [[rviz]]'s plugin loading code. * [[rve_rpc]] is a service-like implementation built on top of topics. This means it can take advantage of [[roscpp]]'s [[roscpp/Overview/Publishers and Subscribers#Intraprocess_Publishing|no-copy intraprocess message passing]]. It also has an asynchronous API (though this could be built for services as well). * [[rve_interface_gen]] takes an interface specification and turns it into C++ code built on top of [[rve_rpc]] * [[rve_properties]] is a property tree system meant for loading/storing arbitrary configuration data. === Messages/Interfaces === The message/interface packages are: * [[rve_msgs]] * [[rve_interfaces]] === 3D Rendering === These packages handle the interfaces to rendering 3D data in a scene. `RVE`'s renderer is split into two parts, the client and the server. Splitting it this way provides a number of advantages: 1. The initial goal with the client/server was to model an [[http://en.wikipedia.org/wiki/Active_object|Active Object]], which allows all rendering to happen in a separate thread from, say, the UI. Because we use [[rve_rpc]] for this, it extends to being able to run the render server in another process as well, or even across the network (on, say, a cluster machine). 1. The only code dependent on [[ogre]] is in the server. Replacing [[ogre]] with something else (such as raw OpenGL) involves only rewriting the server. None of the client code should need to be modified. 1. It allows more control over the rendering being done. Everything going through a custom rendering pipeline (as opposed to direct access to Ogre) allows uniform support for picking, lighting, etc. 1. It opens the possibility of implementing an alternate renderer. For example, one could implement a realtime raytracing renderer for generating super high-quality screenshots or movies The rendering-related packages themselves are: * [[rve_render_server]] provides a render server that is controlled through ROS topics (mainly through [[rve_rpc]]/[[rve_interface_gen]]), and whose output can be subscribed to as <> messages. * [[rve_render_client]] provides a client interface to the render server. * [[rve_mesh_loader]] provides an interface to load mesh files from various formats into an <> message. This is mainly used by [[rve_render_client]]. === Meta-Visualization === The meta-visualization packages map to higher-level concepts useful for writing visualization tools. For example, [[rve_transformer]] package creates a `Transformer` concept that is similar to but more powerful than an [[rviz]] `Display`, the goal being to turn some input data (generally a topic) into renderable output. GUI code that may be useful to multiple projects also fits into this category. * [[rve_transformer]] provides an interface and management of high-level `Transformer` objects, which turn data from one form into another. This includes, for example, both turning a topic into something rendered, and turning mouse/keyboard input into camera movement. * [[rve_common_transformers]] provides some common transformers, and will be fleshed out in time. * [[rve_qt]] has useful Qt widgets, such as a widget which renders an `RVE` scene == Report a Bug == ##<> ##i.e.<> ## AUTOGENERATED DON'T DELETE ## CategoryStack