Vortex Studio SDK Advanced - Cyclone Graphics Engine

Cyclone is the graphics engine used by CM Labs, designed to grow with the performance needs of our simulations.

Cyclone was designed with new lightweight and multi-threaded rendering technologies in mind: Vulkan and DirectX 12. Cyclone reverses the way rendering information is aggregated: the render items are not allowed to do any rendering of their own, rather they should declare what they are adding to the graphics engine.


This section describes the theory used by the Cyclone graphics engine to achieve better performance.

It is important to follow these concepts when you are writing your own graphics extensions.

Data Objects

A data object is a structure that has no functionality or side-effects. It has similar properties as standard C++ primitives such as int and double, but also std::unique_ptr<T> and std::vector<T>. In Cyclone, we introduce various data object classes: Image, Texture, Uniform, Effect, Draw, LevelOfDetail, and Mesh. What distinguishes the Cyclone data objects from similar classes in other graphics engines is that they are completely agnostic data classes, with no direct association to GPU objects. The best example of this is that you cannot request the OpenGL ID for a Cyclone Texture, since that implies a link between the graphics engine and that Cyclone Texture. Rather, you will need to ask the graphics engine for this information, since the graphics engine is responsible for uploading texture to the GPU as well as caching textures through subsequent frames.

Data Objects have the interesting property that they can be created and modified anywhere in the code. We introduce the idea of a copy-on-write pointer in the data object so that any modification to a data object will trigger a cloning of the data object. Snapshots make extensive use of this property of the data objects. Within the snapshot-tracking classes, deep in the graphics engine, the copy-on-write protects the per-frame data so that they remain intact regardless of what the extension does with its data objects on a separate thread.

VxCyclone::Mesh Diagram

The Mesh data object regroups the primitives and represents the input into the programmable rendering pipeline of the graphics card.

VxCyclone::Texture Diagram

The Texture data object brings an image and configures how to use this image.

VxCyclone::EffectState Diagram

The EffectState data object goes one-to-one with the effect data object. It configures the non-programmable parts of the rendering pipeline.

VxCyclone::Effect Diagram

The Effect data object tell the graphics card how to draw; it holds the configuration elements for the rendering pipeline.

The graphics engine will use multiple combined effects to generate the final Effect data object, so extensions will not typically attempt to set all the configuration elements.

VxCyclone::Draw Diagram

The Draw data object represents one selectable draw operation.

It brings together the mesh (the input to the rendering pipeline) and the effect (the configuration of the rendering pipeline) as well as the draw items (how many instances to draw): this defines one draw operation.

Tags are used to indicate in which draw queues to use this draw operation.

View-Managed Textures

View-managed textures are Cyclone textures that are assigned a name in the context of a view. Such view-managed textures thereafter become identifiable through that name in the context of that view. It can then be used in view-texture bindings and render-targets across the view-snapshot and the view-modifiers that would eventually modify the view. In addition, view-managed textures can specify to have their size managed by the view itself. This can be used, for example, so textures used as render-targets declared in a view-modifier-snapshot are properly sized for the view(s) on which the view-modifier is applied.

View-Texture Bindings

View-texture bindings are data structures instructing the graphics engine to dynamically resolve and bind a texture whose exact content is not known in advance. They are necessary when setting up view-managed textures as render-targets and to bind view-managed textures as samplers for pass snapshots (as the underlying Cyclone texture of view-managed textures can be modified by the view). Using a binding allows the graphics engine to resolve and use the current up-to-date Cyclone texture of a view-managed texture. A view-texture binding can be specified to resolve the texture by name or by pass priority and render target attachment point. When resolving by name, the graphics engine will simply look at the view-managed textures from the current view (including all applied view-modifiers) and use the corresponding Cyclone texture. When resolving by pass priority and render target attachment point, the graphics engine will look at what was the last render-target texture attached to the specified attachment point just before the specified pass priority.


Render-targets specify the textures where passes that produce rendering output will write to (e.g., clear-pass, render-pass). Render-targets are specified by assigning a view-texture-binding to an output attachment point (e.g., color buffer 0, depth buffer). This allows targeting a view-managed texture either by its view-managed name or by pass priority and attachment point.

VxCyclone Pass Data Object

There are many types of rendering passes that the pass data-object can express. In order to support the copy-on-write, we have aggregated all the data possibilities within the pass data-object. Depending on the type of the rendering pass, a selection of the members will be used.

The types of rendering passes supported are as follows:

  • CLEAR: Supports up to one color and one depth view-managed texture binding. If the color and/or depth clears are enabled, it will clear the given view-managed textures to the given clear color and/or clear depth.
  • RENDER: Supports a full set of color and one depth view-managed texture binding. It will set-up a render queue for the given tag-set and execute it, drawing all the matching draws on the view-managed textures. An effect can be provided to add uniforms or uniform blocks.
  • FULLSCREEN: Supports a full set of color and one depth view-managed texture binding. It will draw a full-screen quad using the given effect unto the view-managed textures.
  • WINDOW_OUTPUT: This is a final composition step. It will copy the source render targets onto the given window.
  • IMAGE_TRANSFER: Starts a download from the GPU back to the CPU of an image. When the image transfer is completed, the callback in EffectService is triggered with the given image-transfer-identifier.
  • CUSTOM_OPENGL: Supports a full set of color and one depth view-managed texture binding. An effect can be provided to add uniforms or uniform blocks. Executes a lambda-callback function that can do OpenGL.
  • BLIT: Copies a mutli-sample view-managed texture binding onto a non-multi-sample view-managed texture binding.
  • SAMPLE_COUNT_BEGIN / SAMPLE_COUNT_END: Reserved for internal use.

CM Labs offers a list of its own built-in priorities in the VxCyclone::PassPriority enum.

Custom OpenGL Pass

The CUSTOM_OPENGL pass allows executing arbitrary OpenGL code when the graphics engine is rendering a view-snapshot. One registers a callback function that will be called when the pass is executed, on the render thread, and can perform OpenGL calls from that method. When using a CUSTOM_OPENGL pass, you must take care to save and restore any global OpenGL state you change. To assist in that task, the callback function receives a RenderInfo object that allows querying the current rendering parameters and has helpers to save and restore the current OpenGL state.

Execution Policy

There are many cases where you do not want a pass-snapshot to execute every frame. This can be for performance reasons or some accumulation special effects.

In this case, you can set an execution policy to the passes of the pass-snapshot. The execution policy determines when to execute the pass and when to skip it.

The frame indices and counts used by the execution policy are graphics frames, rather than dynamics frames.


A snapshot is a graphical declaration that introduces value into the graphics pipeline. There are a few specializations of snapshots: the DrawSnapshot, ViewSnapshot, and ViewModifierSnapshot. The DrawSnapshot class lists levels of detail (LoDs) with a mesh, an effect and when to draw this mesh and effect combination. The ViewSnapshot class groups passes, declaring a single top-level view idea. The ViewModifierSnapshot class targets existing ViewSnapshot objects and adds graphical elements to them such as additional passes and uniforms.

When designing a Snapshotable extension, you will implement the takeSnapshot function. When your extension's data change, you should call the invalidateSnapshot function to tell the graphics engine that it should request new version(s) of the snapshots. For performance reasons, the takeSnapshot function receives the previous copy of the snapshot held by the graphics engine. If only a few values of your extension's data are changing, you will save a lot of performance by writing over the previous copy rather than creating a brand new snapshot object.

Snapshots are "declare and forget".

Snapshotable and Composite-Snapshotable

A Snapshotable item is an extension that generates snapshots. There are non-extension Snapshotable items, such as the VxGraphics::Viewport, VxGraphics::DrawCall, VxGraphics::DrawText. A CompositeSnapshotable is an interface where Snapshotable items can be grouped. Please note that the snapshots created by a group of Snapshotable items held together in one CompositeSnapshotable item are never processed differently than snapshots coming from independent Snapshotable items.

For future use, it is important for the snapshots to be independent and complete.

The Snapshotable items must not buffer the snapshots, since it is possible for a Snapshotable item (such as an extension) to belong to multiple Snapshotable worlds. When the Snapshotable item is called to create its snapshot(s), it will receive the previous frame's snapshot from the current Snapshotable world. Re-using the previous frame's snapshot is optional, but highly recommended for performance reasons.

Snapshotable Types Diagram


A DrawSnapshot is a collection of draw-items. A draw-item contains a list of LoDs and instances. The graphics engine is responsible for choosing the LoD to draw for each instance and to group the instances together. If the graphics engine receives multiple similar draw-items, it will attempt to merge them. The DrawSnapshot has an isolated flag to indicate that you do not want a draw-item to be merged with identical draw-items. This can be useful if you are culling the instances of a draw-item within your extension. For example, we use this feature in the vegetation field to group the trees pushed within the draw-snapshots.

A draw-item's LoD contains a mesh, an optional effect as well as its selection information. The draw-item selection information consists of the render-tags that will determine when to use this draw-item, the minimum and maximum distances for the LoD selection, a cullable flag, and a bounding box for the culling. A draw-item's instance contains a world-transform specific to this instance, a color, and an object-ID used for picking the instance.


A ViewSnapshot describes a set of rendering operations and outputs to be produced by the renderer on each frame. It contains a list of passes, view-managed-textures, camera parameters and tags. It is the top-level logical rendering scope in Cyclone; all rendering operations happen in the context of a view and must be described through view snapshots or view-modifier snapshots that affect views. Each frame, the graphics engine will process each view and execute a rendering plan corresponding to the described operations. A view-snapshot has a priority that determines its execution order within all view-snapshots active in the graphics engine.

The passes describe the rendering operations to execute. For example, these can include clearing render targets, rendering draw items on render targets, downloading textures, copying textures on window buffers, etc. The view-managed textures are texture objects that get assigned a name in the context of the view. They will be thereafter identifiable by that name in objects that are in the context of that view. The view-managed textures also become usable as render targets for targeted passes in the context of the view. The camera parameters describe the matrices (view, projection) and LoD parameters that will be used for culling and rendering objects.

View-Modifier Snapshots

A ViewModifierSnapshot describes a set of modifications to be applied to views (ViewSnapshot objects) matching certain criteria. It may contain passes, view-managed textures and an optional effect. When applying a view-modifier to a view, the graphics engine will apply the modifier's data on top of what was specified in the view: the passes will be added to the view's passes, any effect will apply on top of the view's base effect and view-managed textures will become available in the scope of the view. ViewModifierSnapshot have a priority that determines the order in which they will be applied to matching views when multiple view-modifiers are applied to a view.

ViewSnapshot and ViewModifierSnapshot objects are matched through tags. The view specifies a set of tags describing the semantics, content and features desired in the view and view-modifiers specify which tags they require before applying to a view. For example, a ViewModifierSnapshot could specify the lit view tag, in which case the graphics engine would only apply the modifier to views having at least the lit tag.

Declarative Engine and Tags

A declarative engine executes in two steps. First, it calls all the graphical elements, including the IDrawable extensions and retrieves their snapshots. Second, it processes and squashes the snapshots into an ordered list of draw-calls. We call those two steps snapshot-retrieval and snapshot-processing.

In order for the snapshot-processing step to make sense of the massive list of snapshots generated during the snapshot-retrieval step, we introduce a system of tags. Tags are assigned to all snapshots and are matched during the snapshot-processing step. Their rules are the following:

  • View-Snapshots use the view-tags to declare what they represent. The official values supported here are: viewport, mirror, ocean/reflection, monitor.
  • ViewModifier-Snapshots declare the view-tags that they affect. The official values supported here are: environment, lit, shadowed, ocean, camera/type/perspective, camera/type/orthographic.
  • Render-Pass-Snapshots declare the render-tags that they want to render. The official values supported here are: background, opaque, vegetation, transparent.
  • Draw-Snapshots declare the render-tags that they render.

Shader Cache

The shader cache contains compiled shaders to be reused and to optimize live loading of shaders. If a developer wants to work on a custom shader, the shader cache will store the compiled shader the first time and keep that version. If changes are made to the shader, the developer can either disable the shader cache completely by deleting the folder %TEMP%/CM Labs/Shader Binaries or by disabling the cache by defining the following environment variable: VXCYCLONEGL_DISABLESHADERCACHE = 1.

Sample Code

Example of draw:

std::shared_ptr<VxCyclone::Snapshot> MyDrawImplementation::takeSnapshot(const std::shared_ptr<VxCyclone::Snapshot>& previous)
	if (!mVisible)
		return nullptr;
	auto snapshot = std::static_pointer_cast<VxCyclone::DrawSnapshot>(previous);
	if (!snapshot)
		snapshot = std::make_shared<VxCyclone::DrawShapshot>();
	VxCyclone::Draw draw;
	VxGraphics::Effect myEffect;
	VxGraphics::Mesh myMesh;
	VxCyclone::TagSet myTags;

	// Prepare effect

	// Prepare the draw (snapshot pipeline)
	// Set Mesh
	size_t positionAttributeIndex = myMesh->addAttribute(VxGraphics::Mesh::FLOAT3, VxGraphics::Mesh::POSITION);
	VxMath::Vector3f* positions = reinterpret_cast<VxMath::Vector3f*>(myMesh->getVertexAttribute(0, positionAttributeIndex));
	*(positions++) = VxMath::Vector3f(-1.0f, -1.0f, -1.0f);
	*(positions++) = VxMath::Vector3f(+1.0f, -1.0f, -1.0f);
	*(positions++) = VxMath::Vector3f(+1.0f, -1.0f, +1.0f);
	*(positions++) = VxMath::Vector3f(-1.0f, -1.0f, +1.0f);
	*(positions++) = VxMath::Vector3f(-1.0f, +1.0f, -1.0f);
	*(positions++) = VxMath::Vector3f(+1.0f, +1.0f, -1.0f);
	*(positions++) = VxMath::Vector3f(+1.0f, +1.0f, +1.0f);
	*(positions++) = VxMath::Vector3f(-1.0f, +1.0f, +1.0f);
	uint16_t* indices = reinterpret_cast<uint16_t*>(myMesh->addPolygonSet(VxGraphics::Mesh::TRIANGLE_LIST, sizeof(uint16_t), 36));
	*(indices++) = 0; *(indices++) = 3; *(indices++) = 2;
	*(indices++) = 0; *(indices++) = 2; *(indices++) = 1;
	*(indices++) = 1; *(indices++) = 2; *(indices++) = 6;
	*(indices++) = 1; *(indices++) = 6; *(indices++) = 5;
	*(indices++) = 5; *(indices++) = 6; *(indices++) = 7;
	*(indices++) = 5; *(indices++) = 7; *(indices++) = 4;
	*(indices++) = 4; *(indices++) = 7; *(indices++) = 3;
	*(indices++) = 4; *(indices++) = 3; *(indices++) = 0;
	*(indices++) = 7; *(indices++) = 6; *(indices++) = 2;
	*(indices++) = 7; *(indices++) = 2; *(indices++) = 3;
	*(indices++) = 5; *(indices++) = 4; *(indices++) = 0;
	*(indices++) = 5; *(indices++) = 0; *(indices++) = 1;

	// set LOD draw
	VxCyclone::DrawLevelOfDetail & drawLod = draw.levelsOfDetailMutable()[0];
	drawLod.mesh = myMesh->getMeshData();
	drawLod.effect = myEffect->getEffectData();
	drawLod.cullable = false;
	myTags << VxCyclone::RenderTags::Opaque;
	drawLod.renderTags = myTags;

	return snapshot;

Example of multi-passes:

std::shared_ptr<VxCyclone::Snapshot> VxGraphics::MyService::takeSnapshot(const std::shared_ptr<VxCyclone::Snapshot>& previous, VxCyclone::ViewSnapshot* view)
	std::vector<VxCyclone::ViewManagedTexture> managedTextures;
	managedTextures.emplace_back(VxCyclone::ViewManagedTexture(HashedStringLiteral("colorTexture"), VxCyclone::Texture::createRenderTargetTexture(VxCyclone::ImageFormat_RGBA), VxCyclone::ViewManagedTexture::FullViewSize));
	managedTextures.emplace_back(VxCyclone::ViewManagedTexture(HashedStringLiteral("depthTexture"), VxCyclone::Texture::createRenderTargetTexture(VxCyclone::ImageFormat_DEPTH32F), VxCyclone::ViewManagedTexture::FullViewSize));
	managedTextures.emplace_back(VxCyclone::ViewManagedTexture(HashedStringLiteral("depthOverlayTexture"), VxCyclone::Texture::createRenderTargetTexture(VxCyclone::ImageFormat_DEPTH32F), VxCyclone::ViewManagedTexture::FullViewSize));
	managedTextures.emplace_back(VxCyclone::ViewManagedTexture(HashedStringLiteral("depthCopyOverlayTexture"), VxCyclone::Texture::createRenderTargetTexture(VxCyclone::ImageFormat_R32F), VxCyclone::ViewManagedTexture::FullViewSize));
	managedTextures.emplace_back(VxCyclone::ViewManagedTexture(HashedStringLiteral("depthIntersectionTexture"), VxCyclone::Texture::createRenderTargetTexture(VxCyclone::ImageFormat_R32F), VxCyclone::ViewManagedTexture::FullViewSize));
	VxCyclone::Effect renderEffect;
	renderEffect.constantDictionaryMutable().setConstantValue("OUTPUT_GBUFFER_COUNT", 1);
	renderEffect.constantDictionaryMutable().setConstantValue("OUTPUT_GBUFFER_ID", 0);
	renderEffect.stateMutable().overrideFlag = true;
	renderEffect.stateMutable().depthTest = VxCyclone::DepthTest_Regular;
	renderEffect.stateMutable().depthWrite = VxCyclone::DepthWrite_Enabled;
	std::vector<std::shared_ptr<VxCyclone::PassSnapshot>> passes;
	// Main objects passes.
		// Clear the RTs.
		VxCyclone::Pass clearPass(VxCyclone::Pass::CLEAR);
		clearPass.setColorClear(Vx::VxColor(0, 1, 1, 0), true);
		clearPass.setDepthClear(0.0f, true);
			<< std::make_pair(VxCyclone::AttachmentPoint_Color0, HashedStringLiteral("colorTexture"))	
			<< std::make_pair(VxCyclone::AttachmentPoint_Depth, HashedStringLiteral("depthTexture")));
		// Render objects.
		VxCyclone::Pass pass(VxCyclone::Pass::RENDER);
			<< std::make_pair(VxCyclone::AttachmentPoint_Color0, HashedStringLiteral("colorTexture"))
			<< std::make_pair(VxCyclone::AttachmentPoint_Depth, HashedStringLiteral("depthTexture")));	

	std::shared_ptr<VxCyclone::ViewModifierSnapshot> snapshot = std::static_pointer_cast<VxCyclone::ViewModifierSnapshot>(previous);
	if (!snapshot) snapshot = std::make_shared<VxCyclone::ViewModifierSnapshot>();
	return snapshot;

CM Labs Graphics Pipeline

This table describes the view creators of the Vortex® Graphics features and extensions.

Feature Name Priority Tags Notes
Context Screenshot Context Screenshot Clear View: <context_name> -int_max   Contains one ClearPass for the "context/screenshot_color_target" render target.
Context Screenshot Context Screenshot Transfer View: <context_name> int_max   Contains one ImageTransferPass for the "context/screenshot_color_target" render target.
Viewport <viewport_name> Customizable, defaults to 0; Negative Values are not allowed. "viewport"
Alternatively for Orthographic cameras, "camera/type/perspective" is replaced by "camera/type/orthographic".
Monitor monitor/<extension_name>/view -100 "monitor"
"shadowed" (option)
Each monitor creates exactly one view snapshot.
We do not support monitors viewing mirrors or the ocean reflection.
Monitors seeings other monitors will have a frame-delay.
Mirror viewport/<viewport_name>/mirror_view -50 "mirror"
"shadowed" (option)
"ocean" (option)
Each mirror create one view snapshot per Viewport.
We do not support mirrors viewing mirrors or the ocean reflection or setting a custom fog for each mirror.
Mirrors seeing monitors will have a frame delay.
Ocean ocean/reflection -2000 + <view_index> "lit" There is no support for shadows, monitors, mirrors or per-viewport fog seen in the ocean reflection.
Statistics internal_view/statistics -1000    
Shadows ShadowManager: Shadow Maps -100 "shadow_maps_renderer"
We support shadows in the scene view, monitors and mirrors.

This table describes the view-modifiers of the Vortex Graphics features and extensions.

Feature Name Priority Tags Notes
Context Screenshot context/screenshot_color_copy_pass   "viewport/<viewport_name>" Contains the "screenshot_color_copy_pass" pass.
Environment     "viewport" "@or" "environment" Adds a CustomOpenGLPass.
Environment SkyDome environment map   "lit" Adds the uniforms and the sampler related to the global sky environment-map.
Fog FogItemImplementation: <fog_item_name> <fog_item_priority> "lit"
"viewport/<viewport_name>" (optional)
Adds the uniforms for the fog.
HMD HeadMountedDisplay Output ViewModifier   "viewport"  
LightingManager LightingManager_OSG ViewModifier   "lit" Adds the uniforms and the sampler related to the lights.
Mirror       Adds the "copy_to_shared" pass
Ocean Triton Ocean -2000 +
"ocean" Draws the ocean surface
Orientor Orientor: View Modifier   "viewport"  
Picking Picking ViewModifier      
Shadows ShadowManager: Shadow Maps Renderer Passes   "shadow_maps_renderer" Contains a series of passes with even/odd priorities where the even priority are clears and the odd priorities are RenderPass with "shadowed"
Shadows ShadowManager: Shadowed View Effect     Introduces shadow-related uniforms to the all the views.
SkyBox SkyBox environment map   "lit" Adds the uniforms and the sampler related to the global sky environment-map.
SoilParticleDisplay soil_particle_display/header   "viewport", "lit"  
Watermark Watermark: View Modifier   "viewport"  

This table covers the different passes declared in Vortex Graphics features and extensions, aimed at VxGraphics::Viewport views.

Feature Type Name Priority Tags Render Targets Notes
Picking ClearPass picking/
  • picking/colorTexture
  • picking/depthTexture
Picking RenderPass picking/
100 "pickable" or
"pickable_collisiongeometry" (option)
"pickable_graphicsnode" (option)
"pickable_graphicsdrawable" (option)
"pickable_accessory" (option)
"pickable_attachment" (option)
"pickable_attachmentpoint" (option)
"pickable_controlpoint" (option)
"pickable_constraint" (option)
"pickable_inertiatensor" (option)
  • picking/colorTexture
  • picking/depthTexture
Picking ClearPass picking/
  • picking/colorTexture
  • picking/depthOverlayTexture
Picking RenderPass picking/
101 "pickable_overlay"
  • picking/colorTexture
  • picking/depthOverlayTexture
Picking ClearPass picking/
102   picking/
Picking FullScreenPass picking/
102   picking/
This pass copies the "picking/depthTexture" render target.
Picking FullScreenPass picking/
102   picking/
This pass copies the "picking/depthOverlayTexture" render target.
Picking ImageTransferPass picking/
103     Downloads the "picking/colorTexture" render target using the "picking/color/<view_name>" transfer ID.
Picking ImageTransferPass picking/
103     Downloads the "picking/depthTexture" render target using the "picking/depth/<view_name>" transfer ID.
Mirror FullScreenPass mirror/
999   mirror/
This pass copies the mirror color buffers to the shared destination texture.
Viewport ClearPass viewport/



Uses a different set of render targets when MSAA is disabled: "viewport/main_color_texture" and "viewport/main_depth_texture".
Environment CustomOpenGLPass  



  <inherited> Draws the sky using the SilverLining atmosphere.
Viewport RenderPass viewport/


"opaque" <inherited>  
Viewport RenderPass viewport/
4001 "@or" "opaque"
Viewport MultisampleBlitPass viewport/
  • viewport/main_color_texture
  • viewport/main_depth_texture
This pass is present only when MSAA is enabled.
Viewport FullScreenPass viewport/
4013   viewport/
This pass copies the render target "viewport/main_color_texture"
Viewport ClearPass viewport/
  • viewport/main_color_texture
  • viewport/main_depth_texture
This is a no-op pass.
SoilParticleDisplay ClearPass soil_particle_display/
  • soil_particle_display_normal/
  • soil_particle_display_depth/
SoilParticleDisplay RenderPass soil_particle_display/
  • soil_particle_display_normal/
  • soil_particle_display_depth/
SoilParticleDisplay FullScreenPass soil_particle_display/
4143   soil_particle_display_blur_normal/
SoilParticleDisplay FullScreenPass soil_particle_display/
4144   <inherited at 4141>  
SoilParticleDisplay ClearPass soil_particle_display/
4145   <inherited at 4141> This is a no-op pass.
SMAA ClearPass  



    Clears the Edge Detection render target.
SMAA IPostEffect   5100     Edge Detection Pass
SMAA IPostEffect   5101     Blending Weight Pass
SMAA IPostEffect   5102     Neighborhood Blending Pass
SSAO IPostEffect  



SSAO IPostEffect   5201      
SSAO IPostEffect   5202      
Ocean RenderPass Triton: Underwater Cylinder 5989 "ocean/underwater cylinder" <inherited>  
Ocean CustomOpenGLPass Triton: Ocean 5990   <inherited> Draws the ocean surface.
Viewport FullScreenPass viewport/
  • viewport/
  • viewport/
This pass is present only when MSAA is enabled.
It copies the <inherited> color render target.
Viewport RenderPass viewport/



"transparent" <inherited> This pass reads in "viewport/depth_copy_texture".
Viewport MultisampleBlitPass viewport/
  • viewport/main_color_texture
  • viewport/main_depth_texture
This pass is present only when MSAA is enabled.
AutomaticExposure SampleCountPass   7080      
AutomaticExposure FullScreenPass Exposure Pass 7081   exposure/main_color_texture  
AutomaticExposure ClearPass exposure/
7082   <inherited at 7080> This is a no-op pass
ColorGrading IPostEffect ColorGrading



Highlight ClearPass  



  <inherited at 7900> Clears the depth map to 0.0.
Highlight RenderPass pre_highlight_pass 7901   <inherited at 7900> Writes only to the depth map.
Highlight RenderPass highlight_pass 7902   <inherited at 7900> Writes the colors with the stipple pattern.
Viewport ClearPass viewport/



  <inherited> This is a depth-only clear.
Viewport RenderPass viewport/
8001 "overlay3d" <inherited>  
FXAA IPostEffect FXAA 9100   IPostEffect  
Colorize IPostEffect Colorize



  IPostEffect Takes in the "picking/colorTexture" render target.
Desaturate IPostEffect Desaturate



HDR IPostEffect hdrpostfx_luminancePass



HDR IPostEffect hdrpostfx_logAvgLumPass 9401   IPostEffect  
HDR IPostEffect hdrpostfx_logAvgLumPass 9402   IPostEffect  
Noise IPostEffect noiseTexture



Orientor RenderPass Orientor: Render Pass 9999 "orientor/renderpass" <inherited>  
Viewport ClearPass viewport/



  <inherited> This is a depth-only clear.
Viewport RenderPass overlay2d 10001 "overlay2d" <inherited>  
Watermark RenderPass Watermark: Render Pass 11999 "watermark" <inherited>  
Viewport WindowsOutputPass viewport/



    This pass is valid only for window contexts.
HMD WindowsOutputPass HeadMountedDisplay/
12000     Submits the left or right eye image to the HMD.
Context Screenshot FullScreenPass context/
12001   context/screenshot_color_target Copies the <inherited> color buffers.