OGRE: Ogre::CompositorManager2 Class Reference

| OGRE 2.2.4 Object-Oriented Graphics Rendering Engine

Classes | Public Types | Public Member Functions | List of all members
Ogre::CompositorManager2 Class Reference
Core | Component » Scene

Main system for managing Render Targets through the use of nodes. More...

`#include <OgreCompositorManager2.h>`

Inheritance diagram for Ogre::CompositorManager2:
[legend]

## Public Types
typedef map< IdString, CompositorNodeDef * >::type | CompositorNodeDefMap

## Public Member Functions
| CompositorManager2 (RenderSystem *renderSystem)
| ~CompositorManager2 ()
void | _swapAllFinalTargets (void)
void | _update (void)
| Will call the renderSystem which in turns calls _updateImplementation. More...
void | _updateImplementation (void)
| This should be called by the render system to perform the actual compositor manager update. More...
void | addListener (CompositorWorkspaceListener *listener)
CompositorNodeDef * | addNodeDefinition (const String &name)
| Returns a new node definition. The name must be unique, throws otherwise. More...
CompositorShadowNodeDef * | addShadowNodeDefinition (const String &name)
| Returns a new node definition. The name must be unique, throws otherwise. More...
CompositorWorkspace * | addWorkspace (SceneManager *sceneManager, const CompositorChannelVec &externalRenderTargets, Camera *defaultCam, IdString definitionName, bool bEnabled, int position=-1, const UavBufferPackedVec *uavBuffers=0, const ResourceLayoutMap *initialLayouts=0, const ResourceAccessMap *initialUavAccess=0, const Vector4 &vpOffsetScale=Vector4::ZERO, uint8 vpModifierMask=0x00, uint8 executionMask=0xFF)
| Overload that allows having multiple external input/outputs. More...
CompositorWorkspace * | addWorkspace (SceneManager *sceneManager, TextureGpu *finalRenderTarget, Camera *defaultCam, IdString definitionName, bool bEnabled, int position=-1, const UavBufferPackedVec *uavBuffers=0, const ResourceLayoutMap *initialLayouts=0, const ResourceAccessMap *initialUavAccess=0, const Vector4 &vpOffsetScale=Vector4::ZERO, uint8 vpModifierMask=0x00, uint8 executionMask=0xFF)
| Main function to start rendering. More...
CompositorWorkspaceDef * | addWorkspaceDefinition (const String &name)
| Returns a new workspace definition. More...
void | connectOutput (CompositorNode *finalNode, size_t inputChannel)
| The final rendering is done by passing the RenderWindow to one of the input channels. More...
void | createBasicWorkspaceDef (const String &workspaceDefName, const ColourValue &backgroundColour, IdString shadowNodeName=IdString())
| Utility helper to create a basic workspace to get you out of the rush. More...
CompositorPassProvider * | getCompositorPassProvider (void) const
size_t | getFrameCount (void) const
| Returns how many times _update has been called. More...
const CompositorNodeDef * | getNodeDefinition (IdString nodeDefName) const
| Returns the node definition with the given name. Throws if not found. More...
CompositorNodeDef * | getNodeDefinitionNonConst (IdString nodeDefName) const
| @See getNodeDefinition. More...
const CompositorNodeDefMap & | getNodeDefinitions (void) const
| Returns a const iterator to all existing definitions. More...
TextureGpu * | getNullShadowTexture (PixelFormatGpu format)
| Get an appropriately defined 'null' texture, i.e. More...
size_t | getNumWorkspaces (void) const
RenderSystem * | getRenderSystem (void) const
const CompositorShadowNodeDef * | getShadowNodeDefinition (IdString nodeDefName) const
| Returns the node definition with the given name. Throws if not found. More...
CompositorShadowNodeDef * | getShadowNodeDefinitionNonConst (IdString nodeDefName) const
| @See getShadowNodeDefinition. More...
v1::Rectangle2D * | getSharedFullscreenQuad (void) const
| Returns a shared fullscreen rectangle/triangle useful for PASS_QUAD passes. More...
v1::Rectangle2D * | getSharedFullscreenTriangle (void) const
| Returns a shared fullscreen rectangle/triangle useful for PASS_QUAD passes. More...
CompositorWorkspaceDef * | getWorkspaceDefinition (IdString name) const
| Returns the workspace definition with the given name. Throws if not found. More...
CompositorWorkspaceDef * | getWorkspaceDefinitionNoThrow (IdString name) const
bool | hasNodeDefinition (IdString nodeDefName) const
| Returns true if a node definition with the given name exists. More...
bool | hasShadowNodeDefinition (IdString nodeDefName) const
| Returns true if a shadow node definition with the given name exists. More...
bool | hasWorkspaceDefinition (IdString name) const
| Returns true if a workspace definition with the given name exists. More...
void | operator delete (void *ptr)
void | operator delete (void *ptr, const char *, int, const char *)
void | operator delete (void *ptr, void *)
void | operator delete[] (void *ptr)
void | operator delete[] (void *ptr, const char *, int, const char *)
void * | operator new (size_t sz)
void * | operator new (size_t sz, const char *file, int line, const char *func)
| operator new, with debug line info More...
void * | operator new (size_t sz, void *ptr)
| placement operator new More...
void * | operator new[] (size_t sz)
void * | operator new[] (size_t sz, const char *file, int line, const char *func)
| array operator new, with debug line info More...
void | removeAllNodeDefinitions (void)
| Removes all node defs. More...
void | removeAllShadowNodeDefinitions (void)
| Removes all shadow nodes defs. More...
void | removeAllWorkspaceDefinitions (void)
void | removeAllWorkspaces (void)
| Removes all workspaces. Make sure you don't hold any reference to a CompositorWorkpace! More...
void | removeListener (CompositorWorkspaceListener *listener)
void | removeNodeDefinition (IdString nodeDefName)
| Removes the node definition with the given name. Throws if not found. More...
void | removeShadowNodeDefinition (IdString nodeDefName)
| Removes the node definition with the given name. Throws if not found. More...
void | removeWorkspace (CompositorWorkspace *workspace)
| Removes the given workspace. Pointer is no longer valid after this call. More...
void | removeWorkspaceDefinition (IdString name)
| Removes the workspace definition with the given name. Throws if not found. More...
void | setCompositorPassProvider (CompositorPassProvider *passProvider)
| Sets a custom pass provider in order to implement custom passes in your nodes. More...
void | validateAllNodes ()
| Calls. More...

## Detailed Description

Main system for managing Render Targets through the use of nodes.

All applications must at least define a workspace definition and create a workspace instance in order to start rendering.

Remarks
  The CompositorManager2 works by defining definitions which tell how the instance will behave. The top down view is the following: Workspace Node Target PASS_SCENE PASS_QUAD PASS_CLEAR PASS_STENCIL PASS_RESOLVE Shadow Node A Node definition must be created first. Inside the Node Def. different passes can be defined including which targets they should render to. Once the definitions are set, a workspace instance must be created using addWorkspace and rendering will start automatically. Each definition is shared by all instances, and is assumed to be immutable (read only) for the life time of those objects.

  If you wish to change the definitions, you should destroy all instances first. In theory many changes can actually happen in real time without any harm, but that depends on how the code was written and thus the behavior is undefined.

  A node has inputs (textures), local textures, and outputs. It can also directly global textures that are defined in a workspace definition. There a few basic rules: Global Textures use the "global_" prefix. For example "global_myRT" is a global texture. Trying to create a Local texture with that name will throw. Global Textures can't be used as node input nor output. Textures that came as Input can be used as Output. A node may have no Input nor Output. Shadow Nodes can't have input, but can have output to be used with other nodes.

  Shadow Nodes are particular case of Nodes which are used for rendering shadow maps, and can only be references from a PASS_SCENE object; and will be executed when that pass is. After the pass is executed, its output can be used for other regular Nodes (i.e. for postprocessing), which enables the possibility of easily creating RSM (Reflective Shadow Maps) for Global Illumination calculations.

  For more information

See also
  CompositorNode &
  CompositorShadowNode

## Member Typedef Documentation

## ◆ CompositorNodeDefMap

typedef map<IdString, CompositorNodeDef*>::type Ogre::CompositorManager2::CompositorNodeDefMap

## Constructor & Destructor Documentation

## ◆ CompositorManager2()

Ogre::CompositorManager2::CompositorManager2 | ( | RenderSystem * | renderSystem | ) |

## ◆ ~CompositorManager2()

Ogre::CompositorManager2::~CompositorManager2 | ( |  | ) |

## Member Function Documentation

## ◆ _swapAllFinalTargets()

void Ogre::CompositorManager2::_swapAllFinalTargets | ( | void |  | ) |

## ◆ _update()

void Ogre::CompositorManager2::_update | ( | void |  | ) |

Will call the renderSystem which in turns calls _updateImplementation.

## ◆ _updateImplementation()

void Ogre::CompositorManager2::_updateImplementation | ( | void |  | ) |

This should be called by the render system to perform the actual compositor manager update.

DO NOT CALL THIS DIRECTLY.

## ◆ addListener()

void Ogre::CompositorManager2::addListener | ( | CompositorWorkspaceListener * | listener | ) |

## ◆ addNodeDefinition()

CompositorNodeDef* Ogre::CompositorManager2::addNodeDefinition | ( | const String & | name | ) |

Returns a new node definition. The name must be unique, throws otherwise.

## ◆ addShadowNodeDefinition()

CompositorShadowNodeDef* Ogre::CompositorManager2::addShadowNodeDefinition | ( | const String & | name | ) |

Returns a new node definition. The name must be unique, throws otherwise.

## ◆ addWorkspace() [1/2]

CompositorWorkspace* Ogre::CompositorManager2::addWorkspace | ( | SceneManager * | sceneManager,
|  | const CompositorChannelVec & | externalRenderTargets,
|  | Camera * | defaultCam,
|  | IdString | definitionName,
|  | bool | bEnabled,
|  | int | position = `-1`,
|  | const UavBufferPackedVec * | uavBuffers = `0`,
|  | const ResourceLayoutMap * | initialLayouts = `0`,
|  | const ResourceAccessMap * | initialUavAccess = `0`,
|  | const Vector4 & | vpOffsetScale = `Vector4::ZERO`,
|  | uint8 | vpModifierMask = `0x00`,
|  | uint8 | executionMask = `0xFF`
| ) |  |

Overload that allows having multiple external input/outputs.

## ◆ addWorkspace() [2/2]

CompositorWorkspace* Ogre::CompositorManager2::addWorkspace | ( | SceneManager * | sceneManager,
|  | TextureGpu * | finalRenderTarget,
|  | Camera * | defaultCam,
|  | IdString | definitionName,
|  | bool | bEnabled,
|  | int | position = `-1`,
|  | const UavBufferPackedVec * | uavBuffers = `0`,
|  | const ResourceLayoutMap * | initialLayouts = `0`,
|  | const ResourceAccessMap * | initialUavAccess = `0`,
|  | const Vector4 & | vpOffsetScale = `Vector4::ZERO`,
|  | uint8 | vpModifierMask = `0x00`,
|  | uint8 | executionMask = `0xFF`
| ) |  |

Main function to start rendering.

Creates a workspace instance based on a workspace definition.

Remarks
  When rendering in stereo using split screen (or when the screen is split to support multiplayer) you can use viewportModifier, vpModifierMask and executionMask parameters to control how the entire workspace renders to a portion of the screen while using two (or more) workspaces without having to duplicate the nodes just to alter their viewport parameters.

viewportModifier controls how to stretch the viewport in each pass, vpModifierMask controls which passes will ignore the stretching, and executionMask controls which passes get skipped.

All passes have a default executionMask = 0xFF vpModifierMask = 0xFF except for clear passes which default to executionMask = 0x01 vpModifierMask = 0x00

The reasoning behind this is that often you want to clear the whole renderTarget the first time (it's GPU-friendly to discard the entire buffer; aka vpModifierMask = 0), but the second time you don't want the clear to be executed at all to prevent overwritting the contents from the first pass (executionMask = 1).

      Example, stereo (split screen):

  Render Eye0 to the left side of the screen m_workspaceEye0 = mgr->addWorkspace( sceneManager, renderTarget, eyeCamera0, "MainWorkspace", true, -1, Vector4( 0, 0, 0.5f, 1 ), 0x01, 0x01 ); Render Eye1 to the right side of the screen m_workspaceEye1 = mgr->addWorkspace( sceneManager, renderTarget, eyeCamera1, "MainWorkspace", true, -1, Vector4( 0.5f, 0, 0.5f, 1 ), 0x02, 0x02 );

      Example, split screen, multiplayer, 4 players (e.g. Mario Kart (R)-like games)
      for( int i=0; i<4; ++i )
      {
          Vector4 vpModifier( (i % 2) * 0.5f, (i >> 1) * 0.5f, 0.25f, 0.25f );
          m_workspace[i] = mgr->addWorkspace( sceneManager, renderTarget,
                                              playerCam[i], "MainWorkspace", true,
                                              -1, vpModifier,
                                              (1 << i), (1 << i) );
      }

Parameters

  sceneManager | The SceneManager this workspace will be associated with. You can have multiple scene managers, each with multiple workspaces. Those workspaces can be set to render to the same final render target, regardless of scene manager (or not).
  finalRenderTarget | The final RT where the workspace will be rendered to. Usually the RenderWindow. We need this pointer in order to correctly create RTTs that depend on the final target's width, height, gamma & fsaa settings. This pointer will be used for "connectOutput" channels (

See also
  CompositorWorkspaceDef::connectOutput) In theory if none of your nodes use width & height relative to final RT & you don't use connectOutput, this pointer could be null. Although it's not recommended nor explicitly supported.

Parameters

  defaultCam | Default camera to use when a camera name wasn't specified explicitly in a pass definition (i.e. PASS_SCENE passes). This pointer can be null if you promise to use all explicit camera names in your passes (and those cameras have already been created)
  definitionName | The unique name of the workspace definition
  bEnabled | True if this workspace should start enabled, false otherwise.
  position | If there are multiple workspaces, specifies the order in which this compositor should be updated. i.e. "0" means this new workspace gets updated first. Note that subsequent calls will place other workspaces to be updated first. Typically you will want to update workspace that renders to the RenderWindow last (depending on what you do with RTs, some OSes, like OS X, may not like it). Defaults to -1; which means update last.
  uavBuffers | Array of UAV Buffers that will be exposed to compositors, via the 'connect_buffer_external' script keyword, or the call CompositorWorkspaceDef::connectExternalBuffer
  vpOffsetScale | The viewport of every pass from every node will be offseted and scaled by the following formula: left += vpOffsetScale.x; top += vpOffsetScale.y; width *= vpOffsetScale.z; height *= vpOffsetScale.w; This affects both the viewport dimensions as well as the scissor rect.
  vpModifierMask | An 8-bit mask that will be AND'ed with the viewport modifier mask of each pass from every node. When the result is zero, the previous parameter "viewportModifier" isn't applied to that pass.

This is useful when you want to apply a pass (like Clear) to the whole render target and not just to the scaled region.

Parameters

  executionMask | An 8-bit mask that will be AND'ed with the execution mask of each pass from every node. When the result is zero, the pass isn't executed. See remarks on how to use this for efficient Stereo or split screen.

This is useful when you want to skip a pass (like Clear) when rendering the second eye (or the second split from the second player).

## ◆ addWorkspaceDefinition()

CompositorWorkspaceDef* Ogre::CompositorManager2::addWorkspaceDefinition | ( | const String & | name | ) |

Returns a new workspace definition.

The name must be unique, throws otherwise.

Remarks
  Setting workspace def's connections must be done after all node definitions have been created

## ◆ connectOutput()

void Ogre::CompositorManager2::connectOutput | ( | CompositorNode * | finalNode,
|  | size_t | inputChannel
| ) |  |

The final rendering is done by passing the RenderWindow to one of the input channels.

This functions does exactly that.

## ◆ createBasicWorkspaceDef()

void Ogre::CompositorManager2::createBasicWorkspaceDef | ( | const String & | workspaceDefName,
|  | const ColourValue & | backgroundColour,
|  | IdString | shadowNodeName = `IdString()`
| ) |  |

Utility helper to create a basic workspace to get you out of the rush.

Advanced users will probably prefer to create the workspace definition using scripts or manipulating functions directly

Parameters

  workspaceDefName | Name to give to the workspace definition. Must be unique
  backgroundColour | Clear colour
  shadowNodeName | Name of the shadow node. Leave blank if no shadows. Caller is supposed to have set the shadow node correctly

## ◆ getCompositorPassProvider()

CompositorPassProvider* Ogre::CompositorManager2::getCompositorPassProvider | ( | void |  | ) | const

## ◆ getFrameCount()

size_t Ogre::CompositorManager2::getFrameCount | ( | void |  | ) | const
| inline

Returns how many times _update has been called.

## ◆ getNodeDefinition()

const CompositorNodeDef* Ogre::CompositorManager2::getNodeDefinition | ( | IdString | nodeDefName | ) | const

Returns the node definition with the given name. Throws if not found.

## ◆ getNodeDefinitionNonConst()

CompositorNodeDef* Ogre::CompositorManager2::getNodeDefinitionNonConst | ( | IdString | nodeDefName | ) | const

@See getNodeDefinition.

Returns a non-const pointer. Use this only if you know what you're doing. Modifying a NodeDef while it's being used by CompositorNode instances is undefined. It's safe if you're sure it's not being used.

## ◆ getNodeDefinitions()

const CompositorNodeDefMap& Ogre::CompositorManager2::getNodeDefinitions | ( | void |  | ) | const
| inline

Returns a const iterator to all existing definitions.

## ◆ getNullShadowTexture()

TextureGpu* Ogre::CompositorManager2::getNullShadowTexture | ( | PixelFormatGpu | format | ) |

Get an appropriately defined 'null' texture, i.e.

one which will always result in no shadows.

## ◆ getNumWorkspaces()

size_t Ogre::CompositorManager2::getNumWorkspaces | ( | void |  | ) | const
| inline

## ◆ getRenderSystem()

RenderSystem* Ogre::CompositorManager2::getRenderSystem | ( | void |  | ) | const

## ◆ getShadowNodeDefinition()

const CompositorShadowNodeDef* Ogre::CompositorManager2::getShadowNodeDefinition | ( | IdString | nodeDefName | ) | const

Returns the node definition with the given name. Throws if not found.

## ◆ getShadowNodeDefinitionNonConst()

CompositorShadowNodeDef* Ogre::CompositorManager2::getShadowNodeDefinitionNonConst | ( | IdString | nodeDefName | ) | const

@See getShadowNodeDefinition.

Returns a non-const pointer. Use this only if you know what you're doing. Modifying a ShadowNodeDef while it's being used by CompositorShadowNode instances is undefined. It's safe if you're sure it's not being used.

## ◆ getSharedFullscreenQuad()

v1::Rectangle2D* Ogre::CompositorManager2::getSharedFullscreenQuad | ( | void |  | ) | const
| inline

Returns a shared fullscreen rectangle/triangle useful for PASS_QUAD passes.

Remarks
  Pointer is valid throughout the lifetime of this CompositorManager2

## ◆ getSharedFullscreenTriangle()

v1::Rectangle2D* Ogre::CompositorManager2::getSharedFullscreenTriangle | ( | void |  | ) | const
| inline

Returns a shared fullscreen rectangle/triangle useful for PASS_QUAD passes.

Remarks
  Pointer is valid throughout the lifetime of this CompositorManager2

## ◆ getWorkspaceDefinition()

CompositorWorkspaceDef* Ogre::CompositorManager2::getWorkspaceDefinition | ( | IdString | name | ) | const

Returns the workspace definition with the given name. Throws if not found.

## ◆ getWorkspaceDefinitionNoThrow()

CompositorWorkspaceDef* Ogre::CompositorManager2::getWorkspaceDefinitionNoThrow | ( | IdString | name | ) | const

## ◆ hasNodeDefinition()

bool Ogre::CompositorManager2::hasNodeDefinition | ( | IdString | nodeDefName | ) | const

Returns true if a node definition with the given name exists.

## ◆ hasShadowNodeDefinition()

bool Ogre::CompositorManager2::hasShadowNodeDefinition | ( | IdString | nodeDefName | ) | const

Returns true if a shadow node definition with the given name exists.

## ◆ hasWorkspaceDefinition()

bool Ogre::CompositorManager2::hasWorkspaceDefinition | ( | IdString | name | ) | const

Returns true if a workspace definition with the given name exists.

## ◆ operator delete() [1/3]

template<class Alloc >

void Ogre::AllocatedObject< Alloc >::operator delete | ( | void * | ptr | ) |
| inlineinherited

## ◆ operator delete() [2/3]

template<class Alloc >

void Ogre::AllocatedObject< Alloc >::operator delete | ( | void * | ptr,
|  | const char * | ,
|  | int | ,
|  | const char * |
| ) |  |
| inlineinherited

## ◆ operator delete() [3/3]

template<class Alloc >

void Ogre::AllocatedObject< Alloc >::operator delete | ( | void * | ptr,
|  | void * |
| ) |  |
| inlineinherited

## ◆ operator delete[]() [1/2]

template<class Alloc >

void Ogre::AllocatedObject< Alloc >::operator delete[] | ( | void * | ptr | ) |
| inlineinherited

## ◆ operator delete[]() [2/2]

template<class Alloc >

void Ogre::AllocatedObject< Alloc >::operator delete[] | ( | void * | ptr,
|  | const char * | ,
|  | int | ,
|  | const char * |
| ) |  |
| inlineinherited

## ◆ operator new() [1/3]

template<class Alloc >

void* Ogre::AllocatedObject< Alloc >::operator new | ( | size_t | sz | ) |
| inlineinherited

## ◆ operator new() [2/3]

template<class Alloc >

void* Ogre::AllocatedObject< Alloc >::operator new | ( | size_t | sz,
|  | const char * | file,
|  | int | line,
|  | const char * | func
| ) |  |
| inlineinherited

operator new, with debug line info

## ◆ operator new() [3/3]

template<class Alloc >

void* Ogre::AllocatedObject< Alloc >::operator new | ( | size_t | sz,
|  | void * | ptr
| ) |  |
| inlineinherited

placement operator new

## ◆ operator new[]() [1/2]

template<class Alloc >

void* Ogre::AllocatedObject< Alloc >::operator new[] | ( | size_t | sz | ) |
| inlineinherited

## ◆ operator new[]() [2/2]

template<class Alloc >

void* Ogre::AllocatedObject< Alloc >::operator new[] | ( | size_t | sz,
|  | const char * | file,
|  | int | line,
|  | const char * | func
| ) |  |
| inlineinherited

array operator new, with debug line info

## ◆ removeAllNodeDefinitions()

void Ogre::CompositorManager2::removeAllNodeDefinitions | ( | void |  | ) |

Removes all node defs.

Make sure there are no active nodes using the definition!

Remarks
  Call removeAllWorkspaceDefinitions first

## ◆ removeAllShadowNodeDefinitions()

void Ogre::CompositorManager2::removeAllShadowNodeDefinitions | ( | void |  | ) |

Removes all shadow nodes defs.

Make sure there are no active nodes using the definition!

Remarks
  Call removeAllWorkspaceDefinitions first

## ◆ removeAllWorkspaceDefinitions()

void Ogre::CompositorManager2::removeAllWorkspaceDefinitions | ( | void |  | ) |

## ◆ removeAllWorkspaces()

void Ogre::CompositorManager2::removeAllWorkspaces | ( | void |  | ) |

Removes all workspaces. Make sure you don't hold any reference to a CompositorWorkpace!

## ◆ removeListener()

void Ogre::CompositorManager2::removeListener | ( | CompositorWorkspaceListener * | listener | ) |

## ◆ removeNodeDefinition()

void Ogre::CompositorManager2::removeNodeDefinition | ( | IdString | nodeDefName | ) |

Removes the node definition with the given name. Throws if not found.

## ◆ removeShadowNodeDefinition()

void Ogre::CompositorManager2::removeShadowNodeDefinition | ( | IdString | nodeDefName | ) |

Removes the node definition with the given name. Throws if not found.

## ◆ removeWorkspace()

void Ogre::CompositorManager2::removeWorkspace | ( | CompositorWorkspace * | workspace | ) |

Removes the given workspace. Pointer is no longer valid after this call.

## ◆ removeWorkspaceDefinition()

void Ogre::CompositorManager2::removeWorkspaceDefinition | ( | IdString | name | ) |

Removes the workspace definition with the given name. Throws if not found.

## ◆ setCompositorPassProvider()

void Ogre::CompositorManager2::setCompositorPassProvider | ( | CompositorPassProvider * | passProvider | ) |

Sets a custom pass provider in order to implement custom passes in your nodes.

See also
  CompositorPassProvider

## ◆ validateAllNodes()

void Ogre::CompositorManager2::validateAllNodes | ( |  | ) |

Calls.

See also
  CompositorNode::_validateAndFinish on all objects who aren't yet validated

The documentation for this class was generated from the following file:

- OgreCompositorManager2.h