A render layer is the building block of your rendering; it is a structure that allows you to set up a single render pass. It acts as a container where objects can be placed for drawing.

There are basically three ways a RenderLayer can draw; using a single Camera; which will be used to render all the Object currently placed on it. The second way to draw a RenderLayer is by associating a Material; this will force the system to draw a full-screen pass. It is ideal to create post-processing effects and use compute Shader.

The last way a RenderLayer can be used is by placing Probe which will be used in turn as cameras drawing their surrounding in an environment map (aka Cubemap) or to a planar Texture.

Static Variables

Name	Description
`scene`	Parent Scene where the RenderLayer is maintained.
Declaration Scene *scene
`camera`	Reference to a Camera that resides in the same Scene where the active RenderLayer is maintained.
Declaration Camera *camera
`material`	The current Material connected to the active RenderLayer forcing it to be draw as a full screen quad.
Declaration Material *material
`sensor`	Force the RenderLayer to use the Actor list of an existing Camera Sensor.
Declaration Sensor *sensor
`uid`	Unique id to identify globally the active RenderLayer.
Declaration unsigned int uid

Variables

Name	Description
`adaptation_method`	The default AdaptationMethod to use for AdaptiveMesh located on the active RenderLayer.
Declaration AdaptationMethod adaptation_method
`adaptation_threshold`	Threshold to use based on the active AdaptationMethod; either triangle count or pixel samples.
Declaration float adaptation_threshold
`adaptation_break`	Force the adaptation system to break and stop refining as soon an acceptable quota is encountered.
Declaration bool adaptation_break
`sorting_method`	Specifies the way to sort the Object located on the active RenderLayer before drawing.
Declaration SortingMethod sorting_method
`name`	Name to identify the current RenderLayer within its parent Scene.
Declaration char *name
`occlusion_mask`	Bit mask of InclusionMask flags to tell the system the type of Object that should be included for occlusion queries.
Declaration int occlusion_mask
`cap`	Unique bit flag to identify the RenderLayer within its parent Scene.
Declaration int cap

Functions

Name	Description
`SetMaterial`	Assign a Material to be used by the RenderLayer forcing it to draw a full screen quad usually used for post-processing effect and compute Shader.
Declaration void SetMaterial( Material material ) Parameters* `material`: A valid reference to an existing Material; to disconnect a previously attached Material set this parameter to `nil`.
`SetCamera`	Assign the Camera to use use to draw the RenderLayer.
Declaration void SetCamera( Camera camera ) Parameters* `camera`: Reference to an existing Camera currently attached to the active Scene.
`SetSensor`	Set which Camera Sensor for the RenderLayer to use in order to generate its render list.
Declaration bool SetSensor( Sensor sensor ) Parameters* `sensor`: Reference to a valid Sensor reference attached to the current RenderLayer Camera. Return Value `true` if the Sensor reference provided is valid; `false` if the Sensor does not belong to the `camera` attached to the active RenderLayer.

InclusionMask

Object class flags used to create an inclusion mask that allows you to include or discard objects of a specific ObjectType.

fEmpty: Flag to include empty Object.
fCamera: Flag to include Camera.
fStaticMesh: Flag to include StaticMesh.
fAdaptiveMesh: Flag to include AdaptiveMesh.
fDynamicMesh: Flag to include DynamicMesh.
fSkeletalMesh: Flag to include SkeletalMesh.
fFracturedMesh: Flag to include FracturedMesh.
fSoundSource: Flag to include SoundSource.
fLightSource: Flag to include LightSource.
fText: Flag to include Text.
fParticleSystem: Flag to include ParticleSystem.
fParticles: Flag to include Particles.
fEnergyField: Flag to include EnergyField.
fRoute: Flag to include Route.
fRay: Flag to include Ray.
fProbe: Flag to include Probe.
fRegion: Flag to include Region.
fOccluder: Flag to include Occluder.
fFastOcclusion: May use a less accurate algorithm, which may be faster, but at the cost of more more false positives.
fNotEqual: Only allow Object that doest not match with the filter to pass through.