engine.render Functions
Warning
The scope of applications for UnigineScript is limited to implementing materials-related logic (material expressions, scriptable materials, brush materials). Do not use UnigineScript as a language for application logic, please consider C#/C++ instead, as these APIs are the preferred ones. Availability of new Engine features in UnigineScipt (beyond its scope of applications) is not guaranteed, as the current level of support assumes only fixing critical issues.
Provides access to Unigine rendering functions. For example, it is used by AppWall application to render onto multiple monitors.
See Also#
- A set of UnigineScript API samples located in the <UnigineSDK>/data/samples/rendering/ folder
Render Class
Members
void engine.render.beginDebugGroup ( string name ) #
Starts a GPU debug group with a specified name in Microprofiler.Arguments
- string name - Name of debug group.
void engine.render.endDebugGroup ( ) #
Ends a GPU debug group previously started via the beginDebugGroup() method.int engine.render.getMaxTextureBufferSize ( ) #
Returns the maximum size of the texture buffer.Return value
Maximum size of the texture buffer.void engine.render.setAlphaFade ( int fade ) #
Console: render_alpha_fade
Enables or disables alpha-blend fading (dithering) for objects. Enabling the feature allows for objects LODs to be smoothly blended into each other over a fade distance.Arguments
- int fade - 1 to enable alpha fading (dithering) for objects, 0 to disable it. The default value is 1.
int engine.render.isAlphaFade ( ) #
Console: render_alpha_fade
Returns a value indicating if alpha-blend fading (dithering) is enabled for objects. When the feature is enabled, objects LODs are smoothly blended into each other over a fade distance.Return value
1 if alpha fading is enabled; otherwise, 0.void engine.render.setAnimationLeaf ( float leaf ) #
Console: render_animation_leaf
Sets the global scale for rotation angle of vegetation leaves.
Arguments
- float leaf - Global leaf rotation angle. If a negative value is provided, 0 will be used instead.
float engine.render.getAnimationLeaf ( ) #
Console: render_animation_leaf
Returns the current scale for rotation angle of vegetation leaves.
Return value
Global leaf rotation angle.float engine.render.getAnimationOldTime ( ) #
Returns the previous render animation time for vegetation.Return value
Animation time in milliseconds.void engine.render.setAnimationScale ( float scale ) #
Console: render_animation_scale
Sets the global scale for rotation speed of vegetation leaves.
Arguments
- float scale - Global leaf rotation speed.
float engine.render.getAnimationScale ( ) #
Console: render_animation_scale
Returns the current global scale for rotation speed of vegetation leaves.
Return value
Global leaf rotation speed.void engine.render.setAnimationStem ( float stem ) #
Console: render_animation_stem
Sets the global scale for movement amplitude of vegetation stems.
Arguments
- float stem - Global stem amplitude scale. If a negative value is provided, 0 will be used instead.
float engine.render.getAnimationStem ( ) #
Console: render_animation_stem
Returns the current global scale for movement amplitude of vegetation stems.
Return value
Global stem amplitude scale.void engine.render.setAnimationTime ( float time ) #
Sets the render animation time for vegetation.Arguments
- float time - Animation time in milliseconds.
float engine.render.getAnimationTime ( ) #
Returns the render animation time for vegetation.Return value
Animation time in milliseconds.void engine.render.setAnimationWind ( vec3 wind ) #
Console: render_animation_wind
Sets the direction of wind for all vegetation (grass and trees). It is a multiplier for the stem offset (in grass, stem and leaves materials).Arguments
- vec3 wind - Offset for vegetation under wind by X, Y and Z axes.
vec3 engine.render.getAnimationWind ( ) #
Console: render_animation_wind
Returns the current direction of wind for all vegetation (grass and trees). It is a multiplier for the stem offset (in grass, stem and leaves materials).Return value
Offset for vegetation under wind by X, Y and Z axes.void engine.render.setBorder ( vec2 border ) #
Console: render_border
Sets width and height of the image border (in pixels), to be rendered outside the horizontal bounds of the screen to reduce artefacts of post effects.Arguments
- vec2 border - Vector with components representing border sizes: X - width, Y - height.
vec2 engine.render.getBorder ( ) #
Console: render_border
Returns current width and height of the image border (in pixels), to be rendered outside the horizontal bounds of the screen to reduce artefacts of post effects.Return value
Vector with components representing border sizes: X - width, Y - height.int engine.render.getAPI ( ) #
Returns the current Graphics API, or API_UNKNOWN if API cannot be identified.Return value
The Graphics API flag (see API_* variables).void engine.render.setAuxiliary ( int auxiliary ) #
Console: render_auxiliary
Enables or disables the auxiliary render buffer usage. The buffer should be enabled for render and post post-processes to work.Arguments
- int auxiliary - 1 to use the auxiliary buffer, 0 not to use. The default value is 1.
int engine.render.isAuxiliary ( ) #
Console: render_auxiliary
Returns a value indicating if auxiliary render buffer is used. The buffer should be enabled for render and post post-processes to work.Return value
1 if the auxiliary buffer is used; otherwise, 0.void engine.render.setBackgroundColor ( vec4 color ) #
Console: render_background_color
Sets the background color by using given vector.Arguments
- vec4 color - A background color vector.
vec4 engine.render.getBackgroundColor ( ) #
Console: render_background_color
Returns the background color vector.Return value
A background color vector.void engine.render.setBentNormalRayTracing ( int tracing ) #
Console: render_bent_normal_ray_tracing
Enables or disables ray-traced bent normals calculation. The use of SSRTGI for bent normals allows for smooth ambient lighting.
Notice
Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Arguments
- int tracing - 1 to enable ray-traced bent normals calculation, 0 to disable. The default value is 1.
int engine.render.isBentNormalRayTracing ( ) #
Console: render_bent_normal_ray_tracing
Returns a value indicating if ray-traced bent normals calculation is enabled. The use of SSRTGI for bent normals allows for smooth ambient lighting.
Notice
Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Return value
1 if ray-traced bent normals calculation is enabled; otherwise, 0.void engine.render.setBentNormalFixOverlitAreas ( int areas ) #
Console: render_bent_normal_fix_overlit_areas
Enables or disables correction of overlit areas for bent normals calculation.
Notice
- This option may significantly affect performance, so disable it when it's not necessary.
- Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int areas - 1 to enable correction of overlit areas for bent normals calculation, 0 to disable it. The default value is 0.
int engine.render.isBentNormalFixOverlitAreas ( ) #
Console: render_bent_normal_fix_overlit_areas
Returns a value indicating if correction of overlit areas for bent normals calculation is enabled.
Notice
- This option may significantly affect performance, so disable it when it's not necessary.
- Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Return value
1 if correction of overlit areas for bent normals calculation is enabled; otherwise, 0.void engine.render.setBentNormalRayTracingDenoise ( int denoise ) #
Enables or disables noise reduction for ray-traced bent normals calculation. This option reduces noise by using the blur effect.Notice
Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Arguments
- int denoise - 1 to enable noise reduction for ray-traced bent normals calculation, 0 to disable. The default value is 1.
int engine.render.isBentNormalRayTracingDenoise ( ) #
Returns a value indicating if noise reduction for ray-traced bent normals calculation is enabled. This option reduces noise by using blur effect.Notice
Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Return value
1 if noise reduction for ray-traced bent normals calculation is enabled; otherwise, 0.void engine.render.setBentNormalRayTracingThreshold ( float threshold ) #
Sets the threshold value for the ray-traced bent normals calculation.Notice
Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Arguments
- float threshold - Bent normals ray tracing threshold value. The default value is 1.0f.
float engine.render.getBentNormalRayTracingThreshold ( ) #
Returns the current threshold value for the ray-traced bent normals calculation.Notice
Ray-traced bent normals calculation available only when the SSRTGI technique is enabled.
Return value
Bent normal ray tracing threshold value. The default value is 1.0f.Texture engine.render.getBlack2DArrayTexture ( ) #
Returns black 2D array texture.Return value
Black 2D array texture.Texture engine.render.getBlack2DTexture ( ) #
Returns black 2D texture.Return value
Black 2D texture.Texture engine.render.getBlack3DTexture ( ) #
Returns black 3D texture.Return value
Black 3D texture.Texture engine.render.getBlackCubeTexture ( ) #
Returns black Cube texture.Return value
Black Cube texture.void engine.render.setBloom ( int bloom ) #
Console: render_bloom
Enables or disables the bloom effect.Arguments
- int bloom - 1 value to enable the bloom effect, 0 to disable.
int engine.render.isBloom ( ) #
Console: render_bloom
Returns a value indicating if the bloom effect is enabled.Return value
1 if the bloom effect is enabled; otherwise, 0.void engine.render.setBloomPasses ( int passes ) #
Console: render_bloom_passes
Sets the number of passes for the bloom effect. During the pass a bloom texture is generating. Up to 8 bloom textures can be generated: each texture has lower resolution (original size, original size /2, original size /4, so forth) with bloom effect. After that, all these bloom textures with the different resolution are composed for the final bloom texture. Arguments
- int passes - Number of bloom passes. The default value is 8. The higher the value the smoother is the effect. However, this option significantly affects performance.
int engine.render.getBloomPasses ( ) #
Console: render_bloom_passes
Returns the current number of passes for the bloom effect. During the pass a bloom texture is generating. Up to 8 bloom textures can be generated: each texture has lower resolution (original size, original size /2, original size /4, so forth) with bloom effect. After that, all these bloom textures with the different resolution are composed for the final bloom texture.Return value
Number of bloom passes.void engine.render.setBloomPower ( float power ) #
Console: render_bloom_power
Sets the power of the bloom effect.
- At the minimum value of 0.0f, the bloom effect is blurred.
- At the maximum value of 1.0f, the bloom effect is more contrast.
Arguments
- float power - Bloom power value within the [0.0f; 1.0f] range. The default value is 0.7f.
float engine.render.getBloomPower ( ) #
Console: render_bloom_power
Returns the power of the bloom effect.
- At the minimum value of 0.0f, the bloom effect is blurred.
- At the maximum value of 1.0f, the bloom effect is more contrast.
Return value
Bloom power value within the [0.0f; 1.0f] range.void engine.render.setBloomResolution ( int resolution ) #
Console: render_bloom_resolution
Sets the resolution of the bloom effect.Arguments
- int resolution - Resolution of the bloom effect:
- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
int engine.render.getBloomResolution ( ) #
Console: render_bloom_resolution
Returns the current resolution of the bloom effect.Return value
Resolution of the bloom effect:- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
void engine.render.setBloomScale ( float scale ) #
Console: render_bloom_scale
Sets the scale of the bloom effect.Arguments
- float scale - Bloom scale value within the [0.0f; 1.0f] range. The default value is 0.3f.
float engine.render.getBloomScale ( ) #
Console: render_bloom_scale
Returns the scale of the bloom effect.Return value
Bloom scale value within the [0.0f; 1.0f] range.void engine.render.setBudget ( float budget ) #
Console: render_budget
Sets the render budget value, which limits the number of loaded/created graphics resources during a frame according to loading/creation time.Arguments
- float budget - Budget value in seconds. The default value is 1/60.
float engine.render.getBudget ( ) #
Console: render_budget
Returns current render budget value, which limits the number of loaded/created graphics resources during a frame according to loading/creation time.Return value
Budget value in seconds. The default value is 1/60.void engine.render.setCameraEffectsThreshold ( float threshold ) #
Console: render_camera_effects_threshold
Sets the threshold, which is used to detect if an object should be blurred in the HDR mode.Arguments
- float threshold - HDR threshold. If a negative value is provided, 0 will be used instead.
float engine.render.getCameraEffectsThreshold ( ) #
Console: render_camera_effects_threshold
Returns the brightness threshold, which is used to detect if an object should be blurred in the HDR mode.Return value
HDR threshold.void engine.render.setClearBufferMask ( int mask ) #
Arguments
- int mask - Buffer mask: one of the RENDER_STATE_BUFFER_* variables.
int engine.render.getClearBufferMask ( ) #
Returns current buffer cleanup mask. This mask determines which buffers are to be cleared next time the Engine::render() is called. This method can be used to save current buffer cleanup mask to restore it later.Return value
Buffer mask: one of the RENDER_STATE_BUFFER_* variables.void engine.render.setCloudDistortionTexture ( int texture ) #
Console: render_clouds_distortion_texture
Sets a value indicating which texture type is to be used for clouds distortion.Arguments
- int texture - One of the following values:
- 0 - 2D Texture - more performance-friendly, but may cause an excessive vertical extrusion of clouds.
- 1 - 3D Texture — ensures homogeneous detail distortion and better image quality, but at a higher performance cost.
int engine.render.getCloudDistortionTexture ( ) #
Console: render_clouds_distortion_texture
Returns a value indicating which texture type is currently used for clouds distortion.Return value
One of the following values:- 0 - 2D Texture - more performance-friendly, but may cause an excessive vertical extrusion of clouds.
- 1 - 3D Texture — ensures homogeneous detail distortion and better image quality, but at a higher performance cost.
void engine.render.setCloudsAccurateLayersSorting ( int sorting ) #
Sets a value indicating if correct sorting of intersecting cloud layers is enabled.Arguments
- int sorting - 1 to enable correct sorting of intersecting cloud layers, 0 to disable it. The default value is 0.
int engine.render.isCloudsAccurateLayersSorting ( ) #
Returns a value indicating if correct sorting of intersecting cloud layers is enabled.Notice
Enabling this feature may reduce raymarching quality as samples shall be distributed among all layers.
Return value
1 if rendering of shadows from the clouds on the ground is enabled; otherwise, 0.void engine.render.setCloudsStepAccuracy ( float accuracy ) #
Console: render_clouds_step_accuracy
Sets the accuracy of ray marching steps. This parameter enables you to improve the visual look of clouds when viewed from inside a cloud layer. It reduces the noise of lighting and clouds shape for long ray marching distances, adds some noise-based blur to a sharp border at the bottom sphere of the cloud layer (rounded) and removes popping effect when leaving a rounded cloud layer.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float accuracy - New accuracy of ray marching steps to be set in the [0.0f; 1.0f] range. Lower numbers gain more performance.
float engine.render.getCloudsStepAccuracy ( ) #
Console: render_clouds_step_accuracy
Returns the current accuracy of ray marching steps. This parameter enables you to improve the visual look of clouds when viewed from inside a cloud layer.Return value
Current accuracy of ray marching steps in the [0.0f; 1.0f] range. The default value is 0.5f.void engine.render.setCloudsDepthBasedReconstruction ( int reconstruction ) #
Sets a value indicating if clouds ray-marched depth is to be used for upsampling the downsampled clouds without obscuring the geometry and reprojection depending on the cloud depth. Recommended for flying through clouds.Notice
Works only with clouds domnsampling rendering mode is set to half and/or clouds interleaved rendering mode is set to 2x2.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int reconstruction - 1 to enable using clouds ray-marched depth for upsampling the downsampled clouds without obscuring the geometry and reprojection depending on the cloud depth; 0 - to disable.
int engine.render.isCloudsDepthBasedReconstruction ( ) #
Returns a value indicating if clouds ray-marched depth is used for upsampling the downsampled clouds without obscuring the geometry and reprojection depending on the cloud depth. Recommended for flying through clouds.Notice
Works only with clouds domnsampling rendering mode is set to half and/or clouds interleaved rendering mode is set to 2x2.
Return value
1 if clouds ray-marched depth is used for upsampling the downsampled clouds without obscuring the geometry and reprojection depending on the cloud depth; otherwise 0.void engine.render.setCloudsDepthBasedReconstructionThreshold ( float threshold ) #
Sets depth threshold value for clouds depth-based reconstruction mode. This value defines the depth difference starting from which pixels are considered to be related to different surfaces.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - New depth threshold value to be set for clouds depth-based reconstruction mode. The default value is 100.0f
float engine.render.getCloudsDepthBasedReconstructionThreshold ( ) #
Returnns the current depth threshold value for clouds depth-based reconstruction mode. This value defines the depth difference starting from which pixels are considered to be related to different surfaces.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current depth threshold value for clouds depth-based reconstruction mode. The default value is 100.0fvoid engine.render.setCloudsDownsamplingRendering ( int rendering ) #
Console: render_clouds_downsampling_rendering
Sets downsampling rendering for clouds. This parameter determines clouds resolution based on current screen resolution. It has a significant impact on performance.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int rendering - One of the following values:
- 0 - full.
- 1 - half (by default).
- 2 - quarter.
int engine.render.getCloudsDownsamplingRendering ( ) #
Console: render_clouds_downsampling_rendering
Returns current downsampling rendering setting for clouds. This parameter determines clouds resolution based on current screen resolution. It has a significant impact on performance.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
One of the following values:- 0 - full.
- 1 - half (by default).
- 2 - quarter.
void engine.render.setCloudsDynamicCoverageArea ( float area ) #
Console: render_clouds_dynamic_coverage_area
Sets dynamic coverage area for clouds. This parameter determines visibility distance for coverage of FieldWeather objects.
Notice
Increasing dynamic coverage area leads to reduction of quality of FieldWeather coverage texture and loss of details. This effect can be mitigated by increasing dynamic coverage resolution using setCloudsDynamicCoverageResolution() method.
Arguments
- float area - Dynamic coverage area, in units. The default value is 10 000.
float engine.render.getCloudsDynamicCoverageArea ( ) #
Console: render_clouds_dynamic_coverage_area
Returns current dynamic coverage area for clouds. This parameter determines visibility distance for coverage of FieldWeather objects.Return value
Dynamic coverage area, in units.void engine.render.setCloudsDynamicCoverageResolution ( int resolution ) #
Sets dynamic coverage resolution for clouds. This parameter determines the quality of dynamic coverage texture for FieldWeather objects. Higher values make it possible to preserve texture details at high distances.Notice
Increased resolution significantly affects performance.
Arguments
- int resolution - One of the following values:
- 0 - 128 x 128.
- 1 - 256 x 256 (by default).
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
int engine.render.getCloudsDynamicCoverageResolution ( ) #
Returns current dynamic coverage resolution setting for clouds. This parameter determines the quality of dynamic coverage texture for FieldWeather objects. Higher values make it possible to preserve texture details at high distances.Return value
One of the following values:- 0 - 128 x 128.
- 1 - 256 x 256 (by default).
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
void engine.render.setCloudsGroundShadows ( int shadows ) #
Console: render_clouds_ground_shadows
Enables or disables rendering of shadows from the clouds on the ground.Arguments
- int shadows - 1 to enable rendering of shadows from the clouds on the ground, 0 to disable it. The default value is 1.
int engine.render.isCloudsGroundShadows ( ) #
Console: render_clouds_ground_shadows
Returns a value indicating if rendering of shadows from the clouds on the ground is enabled.Return value
1 if rendering of shadows from the clouds on the ground is enabled; otherwise, 0.void engine.render.setCloudsInterleavedRendering ( int rendering ) #
Console: render_clouds_interleaved_rendering
Enables or disables interleaved rendering mode for clouds.
Notice
In cases when clouds are viewed from the ground, or from above (at significant distance) and viewer's velocities are less than 200 units per second, this parameter can be used to provide a significant gain in performance.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int rendering - Interleaved rendering mode for clouds:
- 0 - disabled (by default).
- 1 - 2 x 2.
- 2 - 4 x 4.
- 3 - 8 x 8.
int engine.render.getCloudsInterleavedRendering ( ) #
Console: render_clouds_interleaved_rendering
Returns the value indicating current interleaved rendering mode for clouds. This feature can be used to gain performance when enabled. See getCloudsInterleavedRendering().Return value
One of the following values:- 0 - disabled (by default).
- 1 - 2 x 2.
- 2 - 4 x 4.
- 3 - 8 x 8.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setCloudsInterleavedRenderingTemporal ( int temporal ) #
Sets a value indicating if temporal accumulation of noises for interleaved sampling for clouds is enabled.Notice
Works only when clouds interleaved rendering mode set to 2x2.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int temporal - 1 to enable temporal accumulation of noises for interleaved sampling for clouds; 0 - to disable.
int engine.render.isCloudsInterleavedRenderingTemporal ( ) #
Returns a value indicating if temporal accumulation of noises for interleaved sampling for clouds is enabled.Notice
Works only when clouds interleaved rendering mode set to 2x2.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if temporal accumulation of noises for interleaved sampling for clouds is enabled; otherwise 0.void engine.render.setCloudsLightingConeRadius ( float radius ) #
Console: render_clouds_lighting_cone_radius
Sets lighting cone sampling radius for clouds lighting.
Notice
Low values may result in unnatural behavior as the position of the sun changes.
Arguments
- float radius - Lighting cone radius in range [0.0f; 1.0f]. The default value is 0.3.
float engine.render.getCloudsLightingConeRadius ( ) #
Console: render_clouds_lighting_cone_radius
Returns the current lighting cone sampling radius for clouds lighting.Return value
Lighting cone radius in range [0.0f; 1.0f].void engine.render.setCloudsLightingQuality ( int quality ) #
Console: render_clouds_lighting_quality
Sets lighting quality for clouds. This parameter determines the number of samples used to calculate lighting for clouds.
Notice
This parameter has a significant impact on performance. Therefore, it is recommended to use low settings, when possible.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - One of the following values:
- 0 - 1 sample, low quality.
- 1 - 3 samples, medium quality (by default).
- 2 - 5 samples, high quality.
- 3 - 6 samples, ultra quality.
int engine.render.getCloudsLightingQuality ( ) #
Console: render_clouds_lighting_quality
Returns the current lighting quality setting for clouds. This parameter determines the number of samples used to calculate lighting for clouds.Return value
One of the following values:- 0 - 1 sample, low quality.
- 1 - 3 samples, medium quality (by default).
- 2 - 5 samples, high quality.
- 3 - 6 samples, ultra quality.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setCloudsLightingTraceLength ( float length ) #
Console: render_clouds_lighting_tracelength
Sets the lighting trace length for clouds. This parameter determines the maximum length of a sun ray inside a cloud.Arguments
- float length - Lighting trace length in range [1.0f; 2048.0f], in units. The default value is 230.0f.
float engine.render.getCloudsLightingTraceLength ( ) #
Console: render_clouds_lighting_tracelength
Returns the current lighting trace length for clouds. This parameter determines the maximum length of a sun ray inside a cloud.Return value
Lighting trace length, in units.void engine.render.setCloudsNoiseIterations ( float iterations ) #
Console: render_clouds_noise_iterations
Sets the value of the noise iterations parameter for clouds. This parameter determines the amount of jitter, that is used to reduce banding effect due to insufficient number of steps.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float iterations - New value of the noise iterations parameter for clouds. The default value is 0.1f.
float engine.render.getCloudsNoiseIterations ( ) #
Console: render_clouds_noise_iterations
Returns the current value of the noise iterations parameter for the clouds. This parameter determines the amount of jitter, that is used to reduce banding effect due to insufficient number of steps.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current value of the noise iterations parameter for clouds. The default value is 0.1f.void engine.render.setCloudsNoiseLighting ( float lighting ) #
Console: render_clouds_noise_lighting
Sets the value of the noise lighting parameter for clouds. This parameter determines the amount of jitter for tracing steps of lighting calculation, that is used to reduce banding effect due to insufficient number of steps.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float lighting - New value of the noise lighting parameter for clouds. The default value is 0.3f.
float engine.render.getCloudsNoiseLighting ( ) #
Console: render_clouds_noise_lighting
Returns the current value of the noise lighting parameter for the clouds. This parameter determines the amount of jitter for tracing steps of lighting calculation, that is used to reduce banding effect due to insufficient number of steps.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current value of the noise lighting parameter for clouds. The default value is 0.3f.void engine.render.setCloudsNoiseStep ( float step ) #
Console: render_clouds_noise_step
Sets the value of the noise step parameter for clouds. This parameter determines the amount of jitter in the areas within clouds, that is used to reduce banding effect due to insufficient number of steps.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float step - New value of the noise step parameter for clouds. The default value is 0.3f.
float engine.render.getCloudsNoiseStep ( ) #
Console: render_clouds_noise_step
Returns the current value of the noise step parameter for clouds. This parameter determines the amount of jitter in the areas within clouds, that is used to reduce banding effect due to insufficient number of steps.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current value of the noise step parameter for clouds. The default value is 0.3f.void engine.render.setCloudsNoiseStepSkip ( float skip ) #
Console: render_clouds_noise_step_skip
Sets the value of the noise step skip parameter for clouds. This parameter determines the amount of jitter in the areas between clouds, that is used to reduce banding effect due to insufficient number of steps.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float skip - New value of the noise step skip parameter for clouds. The default value is 0.3f.
float engine.render.getCloudsNoiseStepSkip ( ) #
Console: render_clouds_noise_step_skip
Returns the current value of the noise step skip parameter for clouds. This parameter determines the amount of jitter in the areas between clouds, that is used to reduce banding effect due to insufficient number of steps.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current value of the noise step skip parameter for clouds. The default value is 0.3f.void engine.render.setCloudsSamplesCount ( int count ) #
Console: render_clouds_samples_count
Sets the number of samples used for clouds rendering. The higher the value, the less noise in clouds rendering.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int count - Number of samples:
- 0 - low.
- 1 - medium.
- 2 - high (by default).
- 3 - ultra.
int engine.render.getCloudsSamplesCount ( ) #
Console: render_clouds_samples_count
Returns the current number of samples used for clouds rendering. The higher the value, the less noise in clouds rendering.Return value
One of the following values:- 0 - low.
- 1 - medium.
- 2 - high (by default).
- 3 - ultra.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setCloudsSamplingQuality ( int quality ) #
Console: render_clouds_sampling_quality
Sets sampling quality for clouds. This parameter sets the number of noise samples that affects the cloud shape processing quality. The higher the value, the less visual artifacts.
Notice
Visual difference between low and ultra quality is not significant. Therefore, it is recommended to use low settings, when possible, to gain performance.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - Sampling quality:
- 0 - low quality (higher cloud density).
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality (lower density, the clouds are softer).
int engine.render.getCloudsSamplingQuality ( ) #
Console: render_clouds_sampling_quality
Returns the current sampling quality set for clouds. This parameter sets the number of noise samples that affects the cloud shape processing quality. The higher the value, the less visual artifacts.Return value
Sampling quality:- 0 - low quality (higher cloud density).
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality (lower density, the clouds are softer).
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setCloudsSoftIntersection ( float intersection ) #
Console: render_clouds_soft_intersection
Sets the soft intersection distance for clouds.Arguments
- float intersection - Soft intersection distance (in meters) within the [0.0f; 100000.0f] range. The default value is 100.0f.
float engine.render.getCloudsSoftIntersection ( ) #
Console: render_clouds_soft_intersection
Returns the current soft intersection distance for clouds.Return value
Soft intersection distance for clouds, in meters.void engine.render.setCloudsTransparentOrder ( int order ) #
Console: render_clouds_transparent_order
Sets rendering order for clouds relative to transparent objects (except water).Arguments
- int order - Rendering order for clouds relative to transparent objects (except water) to be set. One of the following values:
- 0 - render clouds before all transparent objects.
- 1 - render clouds after all transparent objects.
- 2 - enable rough sorting for transparent objects relative to clouds (below the lowest cloud layer base -> inside the clouds -> above the highest cloud layer top)
int engine.render.getCloudsTransparentOrder ( ) #
Console: render_clouds_transparent_order
Returns the current rendering order for clouds relative to transparent objects (except water).Return value
Current rendering order for clouds relative to transparent objects (except water). One of the following values:- 0 - render clouds before all transparent objects.
- 1 - render clouds after all transparent objects.
- 2 - enable rough sorting for transparent objects relative to clouds (below the lowest cloud layer base -> inside the clouds -> above the highest cloud layer top)
void engine.render.setCloudsQualityPreset ( int preset ) #
Sets the Qlouds Quality preset as currently used.Arguments
- int preset - Qlouds Quality preset index.
int engine.render.getCloudsQualityPreset ( ) #
Returns the index of a currently set Qlouds Quality preset.Return value
Bent Normal preset index.int engine.render.getCloudsQualityPresetNumNames ( ) #
Returns the number of Qlouds Quality presets.Return value
Quantity of Qlouds Quality presets.string engine.render.getCloudsQualityPresetName ( int num ) #
Returns the Qlouds Quality preset name by given index.Arguments
- int num - Qlouds Quality preset index.
Return value
Qlouds Quality preset name.void engine.render.setCloudsLightingSamplesDistribution ( float distribution ) #
Arguments
- float distribution
float engine.render.getCloudsLightingSamplesDistribution ( ) #
void engine.render.setClouds3dTextureHorizontalResolution ( int resolution ) #
Arguments
- int resolution
int engine.render.getClouds3dTextureHorizontalResolution ( ) #
void engine.render.setClouds3dTextureVerticalResolution ( int resolution ) #
Arguments
- int resolution
int engine.render.getClouds3dTextureVerticalResolution ( ) #
void engine.render.setColorCorrectionBrightness ( float brightness ) #
Sets the current brightness of the scene.Arguments
- float brightness - Brightness. The provided value is saturated in the range [-1.0f; 1.0f].
float engine.render.getColorCorrectionBrightness ( ) #
Returns the current overall brightness of the scene.Return value
Current brightness.void engine.render.setColorCorrectionContrast ( float contrast ) #
Sets the current contrast of the scene.Arguments
- float contrast - Contrast. The provided value is saturated in the range [-1.0f; 1.0f].
float engine.render.getColorCorrectionContrast ( ) #
Returns the current overall contrast of the scene.Return value
Current contrast.void engine.render.setColorCorrectionGamma ( float gamma ) #
Sets the current gamma of the scene.Arguments
- float gamma - Gamma. The provided value is saturated in the range [0.5f; 1.5f].
float engine.render.getColorCorrectionGamma ( ) #
Returns the current overall gamma of the scene.Return value
Current gamma.int engine.render.setColorCorrectionLUTImage ( Image image ) #
Sets a new color transformation image (LUT). This function resets a LUT texture name to null if it has been previously set via setColorCorrectionLUTPath().Source code (UnigineScript)
Image lut;
Image lut_0;
Image lut_1;
if(lut == NULL) {
lut = new Image();
lut_0 = new Image("unigine_project/textures/lookup_first.dds");
lut_1 = new Image("unigine_project/textures/lookup_second.dds");
}
float k = sin(engine.game.getTime() * 2.0f) * 0.5f + 0.5f;
lut.copy(lut_0);
lut.blend(lut_1,0,0,0,0,lut.getWidth(),lut.getHeight(),k);
engine.render.setColorCorrectionLUTImage(lut);Arguments
- Image image - Color transformation image.
Return value
1 if the image is set successfully; otherwise, 0.int engine.render.getColorCorrectionLUTImage ( Image image ) #
Return the current color transformation image (LUT).Arguments
- Image image - Image to store the color transformation texture in.
Return value
1 if an image is successfully received; otherwise, 0.void engine.render.setColorCorrectionLUTPath ( string path ) #
Sets the name of a new color transformation texture (LUT).Arguments
- string path - Name of the file with the texture. If NULL (0) is passed, the texture is cleared.
string engine.render.getColorCorrectionLUTPath ( ) #
Returns the name of the current color transformation texture (LUT).Return value
Name of the current color transformation texture.TextureCurve engine.render.getColorCorrectionCurve ( ) #
Returns the current Color Correction curve texture.Return value
An instance of the TextureCurve class with 4 channels:- Channels 0, 1, 2 - the Red, Green and Blue channels of the Color Correction curve.
- Channel 3 - the Saturation Correction curve.
void engine.render.resetColorCorrectionCurve ( ) #
Resets the Color Correction curve to the default value.
void engine.render.resetColorCorrectionSaturationCurve ( ) #
Resets the Saturation Correction curve to the default value.
void engine.render.setColorCorrectionSaturation ( ) #
Sets the current saturation adjustment values.Arguments
Palette engine.render.getColorCorrectionSaturation ( ) #
Returns the current saturation adjustment values.Return value
A Palette structure.void engine.render.setColorCorrectionPreserveSaturation ( int saturation ) #
Sets a value indicating if initial scene color saturation is to be preserved after applying color correction.Arguments
- int saturation - 1 to preserve initial scene color saturation after applying color correction; otherwise, 0.
int engine.render.isColorCorrectionPreserveSaturation ( ) #
Returns a value indicating if initial scene color saturation is to be preserved after applying color correction.Return value
1 if initial scene color saturation is to be preserved after applying color correction; otherwise, 0.void engine.render.setColorCorrectionHueShift ( ) #
Sets the current hue adjustment values.Arguments
Palette engine.render.getColorCorrectionHueShift ( ) #
Returns the current hue adjustment values.Return value
A Palette structure.void engine.render.setColorCorrectionWhite ( vec4 white ) #
Sets the current white balance of the scene.Arguments
- vec4 white - White balance. The provided value is saturated in the range [vec4_epsilon;vec4_one].
vec4 engine.render.getColorCorrectionWhite ( ) #
Returns the current white balance of the scene.Return value
Current white balance.void engine.render.setCompositeMaterial ( string material ) #
Sets a custom composite material that specifies a custom shader used for the final composition of the full-screen image instead of the default one.Arguments
- string material - Composite material name.
string engine.render.getCompositeMaterial ( ) #
Returns a name of the current composite material that specifies a custom shader used for the final composition of the full-screen image instead of the default one.Return value
Name of the current composite material.void engine.render.setCross ( int cross ) #
Console: render_cross
Enables or disables cross flares.Arguments
- int cross - 1 to enable cross flares, 0 to disable.
int engine.render.isCross ( ) #
Console: render_cross
Returns a value indicating if cross flares are enabled.Return value
1 if cross flares are enabled; otherwise, 0.void engine.render.setCrossAngle ( float angle ) #
Console: render_cross_angle
Sets the cross flares orientation angle.Arguments
- float angle - Angle in degrees.
float engine.render.getCrossAngle ( ) #
Console: render_cross_angle
Returns the cross flares orientation angle.Return value
Angle between flare shafts in degrees.void engine.render.setCrossColor ( vec4 color ) #
Console: render_cross_color
Sets the color of the cross flares.Arguments
- vec4 color - Color of cross flares.
vec4 engine.render.getCrossColor ( ) #
Console: render_cross_color
Returns the color of the cross flares.Return value
Color of the cross flares.void engine.render.setCrossLength ( float length ) #
Console: render_cross_length
Sets the length of a cross flare. Increasing this value also leads to fading of the shafts across their length.Arguments
- float length - Length of a cross flare relative to the screen width.
float engine.render.getCrossLength ( ) #
Console: render_cross_length
Returns the length of a cross flare.Return value
Length of a cross flare relative to the screen width.void engine.render.setCrossScale ( float scale ) #
Console: render_cross_scale
Sets a multiplier for color of cross flares.Arguments
- float scale - Cross color scale. If a negative value is provided, 0 will be used instead.
float engine.render.getCrossScale ( ) #
Console: render_cross_scale
Returns the current multiplier for color of cross flares.Return value
Cross color scale.void engine.render.setCrossShafts ( int shafts ) #
Console: render_cross_shafts
Sets the number of shafts in a cross flare.
- The minimum number of shafts is 2.
- The maximum number of shafts is 32 (high number of flares can cause FPS drop on low-performance hardware).
Arguments
- int shafts - The number of a cross flares. The provided value is saturated in the range [2; 32].
int engine.render.getCrossShafts ( ) #
Console: render_cross_shafts
Returns the number of shafts in a cross flare.
- The minimum number of shafts is 2.
- The maximum number of shafts is 32 (high number of flares can cause FPS drop on low-performance hardware).
Return value
Number of cross flares.void engine.render.setCrossThreshold ( float threshold ) #
Console: render_cross_threshold
Sets the brightness threshold for areas to produce flare: the higher the threshold value, the brighter the area should be to produce a flare.Arguments
- float threshold - Cross flares threshold.
float engine.render.getCrossThreshold ( ) #
Console: render_cross_threshold
Returns the current brightness threshold for areas to produce flare.Return value
Cross flares threshold.void engine.render.setData ( string data ) #
Sets user data associated with the render. This string is written directly into a *.world file. Namely, into the data child tag of the render tag, for example:Source code (XML)
<world version="1.21">
<render>
<data>User data</data>
</render>
</world>Arguments
- string data - New user data. The data can contain an XML formatted string.
string engine.render.getData ( ) #
Returns user data associated with the render. This string is written directly into a *.world file. Namely, into the data child tag of the render tag, for example:Source code (XML)
<world version="1.21">
<render>
<data>User data</data>
</render>
</world>Return value
User data. The data can contain an XML formatted string.void engine.render.setDebug ( int debug ) #
Console: render_debug
Enables or disables rendering of debug materials (the debug_materials material). Debug materials can be used for debugging of image generation stages. For example, you can render only SSR, or only cubemaps and so on.Arguments
- int debug - 1 to enable rendering of debug materials, 0 to disable it. The default value is 0.
int engine.render.isDebug ( ) #
Console: render_debug
Returns the value indicating whether debug materials (the debug_materials material) are rendered or not. Debug materials can be used for debugging of image generation stages.Return value
1 if debug materials are rendered; otherwise, 0.void engine.render.setDebugMaterials ( string materials ) #
Updates the list of debug materials to be rendered.Notice
Rendering of debug materials must be enabled (see the setDebug() method).
Arguments
- string materials - List of debug materials (a comma separated string, e.g., "mat_1, mat_2, ... mat_n").
string engine.render.getDebugMaterials ( ) #
Returns the list of debug materials to be rendered as a string constant.Notice
Rendering of debug materials must be enabled (see the setDebug() method).
Return value
List of debug materials (a comma separated string, e.g., "mat_1, mat_2, ... mat_n").void engine.render.setDecalDistance ( float distance ) #
Console: render_decal_distance
Sets the distance, at which (and farther) decals will not be rendered.Arguments
- float distance - Distance in units.
float engine.render.getDecalDistance ( ) #
Console: render_decal_distance
Returns the distance, at which (and farther) decals will not be rendered.Return value
Distance in units.void engine.render.setDecals ( int decals ) #
Console: render_decals
Enables or disables rendering of decals.Arguments
- int decals - 1 to enable rendering of decals, 0 to disable it. The default value is 1.
int engine.render.isDecals ( ) #
Console: render_decals
Returns the value indicating if rendering of decals is enabled.Return value
1 if rendering of decals is enabled; otherwise, 0.void engine.render.setDeferredMaterial ( string material ) #
Updates the list of materials that will be used on the Deferred Composite stage of rendering sequence. A debug material can be put here in order to be added to the final image.Arguments
- string material - List of composite deferred materials (a comma separated string, e.g., "mat_1, mat_2, ... mat_n").
string engine.render.getDeferredMaterial ( ) #
Returns the list of materials that are used on the Deferred Composite stage of rendering sequence.Return value
List of deferred materials (a comma separated string, e.g., "mat_1, mat_2, ... mat_n").void engine.render.setDirtScale ( float scale ) #
Console: render_dirt_scale
Sets the scale of lens dirt effect modulating the pattern of lens flares. For example, it can be used to create an effect of unclean optics when the camera looks at the sun.Arguments
- float scale - Dirt scale value within the [0.0f; 1.0f] range. The default value is 0.5f.
float engine.render.getDirtScale ( ) #
Console: render_dirt_scale
Returns the scale of lens dirt effect modulating the pattern of lens flares.Return value
Dirt scale value within the [0.0f; 1.0f] range.void engine.render.setDirtTextureName ( string name ) #
Sets the texture that modulates the pattern of lens flares. For example, it can be used to create an effect of unclean optics when the camera looks at the sun.Arguments
- string name - Name of the lens flares modulation texture.
string engine.render.getDirtTextureName ( ) #
Returns the name of the current texture that modulates the pattern of lens flares. For example, it can be used to create an effect of light reflections or unclean optics when the camera looks at the sun.Return value
Name of the lens flares modulation texture.void engine.render.setDistanceScale ( float scale ) #
Console: render_distance_scale
Sets the global distance scale for all distance parameters: shadow distance, light distance, LOD distances, etc.Arguments
- float scale - Global distance scale.
float engine.render.getDistanceScale ( ) #
Console: render_distance_scale
Returns the current global distance scale for all distance parameters: shadow distance, world lights shadows, LOD distances, etc.Return value
Global distance scale.void engine.render.setDOF ( int dof ) #
Console: render_dof
Enables or disables the DOF (Depth Of Field) effect.Arguments
- int dof - 1 to enable the DOF effect, 0 to disable it. The default value is 0.
int engine.render.isDOF ( ) #
Console: render_dof
Returns the value indicating if the DOF (Depth Of Field) effect is enabled.Return value
1 if the DOF effect is enabled; otherwise, 0.void engine.render.setDOFBlur ( float blur ) #
Console: render_dof_blur
Sets the intensity of blur for the DOF (Depth Of Field) effect.Arguments
- float blur - DOF blur intensity value. The default value is 1.0f.
float engine.render.getDOFBlur ( ) #
Console: render_dof_blur
Returns the intensity of blur for the DOF (Depth Of Field) effect.Return value
DoF blur intensity value.void engine.render.setDOFBokehMode ( int mode ) #
Console: render_dof_bokeh_mode
Sets the shape of the Bokeh for the DOF effect. This parameter determines the way the lens renders out-of-focus points of light.
Notice
For the DOF effect, the Bokeh effect is enabled by default.
Arguments
- int mode - The Bokeh shape:
- 0 - ring (by default).
- 1 - circle.
int engine.render.getDOFBokehMode ( ) #
Console: render_dof_bokeh_mode
Returns the current shape of the Bokeh for the DOF effect. This parameter determines the way the lens renders out-of-focus points of light.
Notice
For the DOF effect, the Bokeh effect is enabled by default.
Return value
The Bokeh shape:- 0 - ring (by default).
- 1 - circle.
void engine.render.setDOFChromaticAberration ( float aberration ) #
Console: render_dof_chromatic_aberration
Sets the intensity of chromatic aberration for the DOF (Depth Of Field) effect.Arguments
- float aberration - DOF chromatic aberration intensity value. The default value is 0.0f.
float engine.render.getDOFChromaticAberration ( ) #
Console: render_dof_chromatic_aberration
Returns the intensity of chromatic aberration for the DOF (Depth Of Field) effect.Return value
DOF chromatic aberration intensity value.void engine.render.setDOFFarDistance ( float distance ) #
Console: render_dof_far_distance
Sets the far DOF limit of the camera: the distance between the camera and the furthest element that is considered to be acceptably sharp. Black zone on the DOF mask means in-focus zone. Arguments
- float distance - Far DOF limit value in units.
float engine.render.getDOFFarDistance ( ) #
Console: render_dof_far_distance
Returns the far DOF limit of the camera: the distance between the camera and the furthest element that is considered to be acceptably sharp. Black zone on the DOF mask means in-focus zone.Return value
Far DOF limit value in units.void engine.render.setDOFFarFocalOffset ( float offset ) #
Console: render_dof_far_focal_offset
Sets the offset from the focal to the farthest blurred zone for the DOF effect. In other words, the distance when background (far) is in focus.Arguments
- float offset - Far DOF focal offset value in units.
float engine.render.getDOFFarFocalOffset ( ) #
Console: render_dof_far_focal_offset
Returns the offset from the focal to the farthest blurred zone. In other words, the distance when background (far) is in focus.Return value
Far DOF focal offset value in units.void engine.render.setDOFFocalDistance ( float distance ) #
Console: render_dof_focal_distance
Sets the focal distance of the camera, i.e. a point where objects are in-focus and visible clearly.Arguments
- float distance - Focal distance in units. If a negative value is provided, 0 will be used instead.
float engine.render.getDOFFocalDistance ( ) #
Console: render_dof_focal_distance
Returns the focal distance of the camera, i.e. a point where objects are in-focus and visible clearly.Return value
Focal distance in units.void engine.render.setDOFFocusImprovement ( int improvement ) #
Console: render_dof_focus_improvement
Enables or disables focus improvement for the DOF (Depth Of Field) effect. When enabled, transitions between the focused and unfocused parts of the scene become more accurate.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int improvement - 1 to enable focus improvement for the DOF effect, 0 to disable it. The default value is 0.
int engine.render.isDOFFocusImprovement ( ) #
Console: render_dof_focus_improvement
Returns a value indicating if the focus improvement option is enabled for the DOF (Depth Of Field) effect. When enabled, transitions between the focused and unfocused parts of the scene become more accurate.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if focus improvement is enabled for the DOF effect; otherwise, 0.void engine.render.setDOFIncreasedAccuracy ( int accuracy ) #
Console: render_dof_increased_accuracy
Enables or disables increased accuracy for the DOF (Depth Of Field) effect. Enabling the parameter allows for increasing accuracy of focusing calculation.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int accuracy - 1 to enable increased accuracy for the DOF effect, 0 to disable it. The default value is 0.
int engine.render.isDOFIncreasedAccuracy ( ) #
Console: render_dof_increased_accuracy
Returns a value indicating if the increased accuracy option is enabled for the DOF (Depth Of Field) effect. When enabled, focusing calculation is performed with increased accuracy.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if increased accuracy is enabled for the DOF effect; otherwise, 0.void engine.render.setDOFNearDistance ( float distance ) #
Console: render_dof_near_distance
Sets the near DOF limit of the camera: the distance between the camera and the first element that is considered to be acceptably sharp. Black zone on the DOF mask means in-focus zone.Arguments
- float distance - Near DOF limit value in units.
float engine.render.getDOFNearDistance ( ) #
Console: render_dof_near_distance
Returns the near DOF limit of the camera: the distance between the camera and the first element that is considered to be acceptably sharp. Black zone on the DOF mask means in-focus zone.Return value
Near DOF limit value in units.void engine.render.setDOFNearFocalOffset ( float offset ) #
Console: render_dof_near_focal_offset
Sets the offset from the focal to the nearest blurred zone. In other words, the distance when foreground (far) is in focus.Arguments
- float offset - Near DOF focal offset value in units.
float engine.render.getDOFNearFocalOffset ( ) #
Console: render_dof_near_focal_offset
Returns the offset from the focal to the nearest blurred zone. In other words, the distance when foreground (far) is in focus.Return value
Near DOF focal offset value in units.void engine.render.setDOFQuality ( int quality ) #
Console: render_dof_quality
Sets the quality of the DOF (Depth Of Field) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - The value indicating quality of the DOF effect:
- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
int engine.render.getDOFQuality ( ) #
Console: render_dof_quality
Returns the value indicating the quality of the DOF (Depth Of Field) effect.Return value
The value indicating quality of the DOF effect:- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setDOFResolution ( int resolution ) #
Console: render_dof_resolution
Sets the resolution of the DOF (Depth Of Field) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int resolution - Resolution of the DOF effect:
- 0 - quarter resolution.
- 1 - half resolution.
- 2 - full resolution (by default).
int engine.render.getDOFResolution ( ) #
Console: render_dof_resolution
Returns the resolution of the DOF (Depth Of Field) effect.Return value
Resolution of the DOF effect:- 0 - quarter resolution.
- 1 - half resolution.
- 2 - full resolution (by default).
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setEnabled ( int arg1 ) #
Enables or disables the render.Arguments
- int arg1 - 1 to enable the render, 0 to disable it.
int engine.render.isEnabled ( ) #
Returns a value indicating if the render is enabled.Return value
1 if the render is enabled; otherwise, 0.void engine.render.setEnvironment ( int environment ) #
Console: render_environment
Enables or disables rendering of environment of the scene.Arguments
- int environment - 1 to enable rendering of environment, 0 to disable it. The default value is 1.
int engine.render.isEnvironment ( ) #
Console: render_environment
Returns the value indicating if rendering of environment of the scene is enabled.Return value
1 rendering of environment is enabled; otherwise, 0.void engine.render.setEnvironmentCubemapBlendMode ( int mode ) #
Console: render_environment_cubemap_blend
Sets the environment cubemap blending mode.Arguments
- int mode - Cubemap blending mode:
- 0 - alpha blend (by default).
- 1 - additive blend.
- 2 - multiply.
- 3 - overlay.
int engine.render.getEnvironmentCubemapBlendMode ( ) #
Console: render_environment_cubemap_blend
Returns the current environment cubemap blending mode.Return value
Cubemap blending mode:- 0 - alpha blend (by default).
- 1 - additive blend.
- 2 - multiply.
- 3 - overlay.
void engine.render.setEnvironmentHazeMode ( int mode ) #
Console: render_environment_haze
Sets the mode for the haze effect.Arguments
- int mode - Haze mode: one of the RENDER_HAZE_* variables.
int engine.render.getEnvironmentHazeMode ( ) #
Console: render_environment_haze
Returns the current mode set for the haze effect.Return value
Haze mode: one of the RENDER_HAZE_* variables.void engine.render.setExposure ( float exposure ) #
Console: render_exposure
Sets the camera exposure (a multiplier of the scene luminance and brightness). It determines the resulting amount of luminance:
- By the minimum value of 0.0f, the image is rendered black.
- The higher the value, the more luminance and the brighter the scene lit.
Arguments
- float exposure - Multiplier of the scene luminance and brightness.
float engine.render.getExposure ( ) #
Console: render_exposure
Returns the current camera exposure (a multiplier of the scene luminance and brightness.). It determines the resulting amount of luminance:
- By the minimum value of 0.0f, the image is rendered black.
- The higher the value, the more luminance and the brighter the scene lit.
Return value
Current multiplier of the scene luminance and brightness.void engine.render.setExposureAdaptation ( float adaptation ) #
Console: render_exposure_adaptation
Sets the time for the camera to adjust exposure. If 0.0f is set, instant adaptation will be used.Arguments
- float adaptation - Period of exposure adaptation in seconds. If a too small or even negative value is provided, 1E-6 will be used instead.
float engine.render.getExposureAdaptation ( ) #
Console: render_exposure_adaptation
Returns the current the time set for the camera to adjust exposure. If the 0.0f is returned, it means that instant adaptation is used.Return value
Period of exposure adaptation in seconds.void engine.render.setExposureMaxLuminance ( float luminance ) #
Sets the maximum luminance offset relative to the default luminance of the scene used for rendering of adaptive exposure effect: the lower the value, the brighter the adapted image will be. The parameter can take on negative values.Notice
If the specified value is less than the current minimum luminance, the minimum luminance value will be changed to the specified maximum luminance so that they are equal.
Arguments
- float luminance - Maximum luminance. The provided value is saturated in the range [-10.0f; 10.0f].
float engine.render.getExposureMaxLuminance ( ) #
Returns the maximum luminance offset relative to the default luminance of the scene used for rendering of adaptive exposure effect: the lower the value, the brighter the adapted image is.Return value
Maximum luminance.void engine.render.setExposureMinLuminance ( float luminance ) #
Sets the minimum luminance offset relative to the default luminance of the scene used for rendering of adaptive exposure effect: the higher the value, the darker the adapted image will be. The parameter can take on negative values.Notice
If the specified value is greater than the current maximum luminance, the maximum luminance value will be changed to the specified minimum luminance so that they are equal.
Arguments
- float luminance - Minimum luminance. The provided value is clamped to the range [-10.0f; 10.0f].
float engine.render.getExposureMinLuminance ( ) #
Returns the minimum luminance offset relative to the default luminance of the scene used for rendering of adaptive exposure effect: the higher the value, the darker the adapted image is.Return value
Minimum luminance.void engine.render.setExposureMode ( int mode ) #
Console: render_exposure_mode
Sets the mode of the adaptive exposure effect.Arguments
- int mode - The value indicating the exposure mode:
- 0 - a static exposure. The amount of luminance is determined by the setExposure().
- 1 - adaptive logarithmic mapping technique.
- 2 - adaptive quadratic mapping technique.
int engine.render.getExposureMode ( ) #
Console: render_exposure_mode
Returns current adaptive exposure mode:
- 0 - a static exposure. The amount of luminance is determined by the setExposure().
- 1 - adaptive logarithmic mapping technique.
- 2 - adaptive quadratic mapping technique.
Return value
The type of the exposure mode.void engine.render.setFadeColor ( vec4 color ) #
Console: render_fade_color
Sets the current fade color for the scene on the screen. By gradually changing this value it is possible to create "fade in" and "fade out" effects depending on the w component of the given vector. For example, when the following vectors are passed the result will be:
- vec4(1,1,1,1) - a fully white screen. Positive w results in additive blending.
- vec4(0.5,0.5,0.5,1) - light colors on the screen.
- vec4(1,0,0,1) - R channel for all screen colors is to its maximum; G and B without changes.
- vec4(0,0,0,0) - there is no fading (no color alterations are done to the screen).
- vec4(1,1,1,-1) - a fully black screen. Negative w results inscene colors * (1 - RGB), where RGB is the first three components of the passed vector.
- vec4(0.5,0.5,0.5,-1) - dark colors on the screen.
Arguments
- vec4 color - Fade color for the scene on the screen. The provided vector represents RGB channel values (first three components) and a fading coefficient (w component). All components are saturated in the range [-1; 1].
vec4 engine.render.getFadeColor ( ) #
Console: render_fade_color
Returns the current fade color of the scene.Return value
Current fade color.void engine.render.setFieldDistance ( float distance ) #
Console: render_field_distance
Sets the distance, at which (and farther) Field nodes will not be rendered.Arguments
- float distance - Distance in units.
float engine.render.getFieldDistance ( ) #
Console: render_field_distance
Returns the distance, at which (and farther) Field nodes will not be rendered.Return value
Distance in units.void engine.render.setFieldHeightResolution ( int resolution ) #
Console: render_field_height_resolution
Sets the resolution of the FieldHeight.Arguments
- int resolution - One of the following values:
- 0 - 128 x 128.
- 1 - 256 x 256.
- 2 - 512 x 512 (by default).
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192.
int engine.render.getFieldHeightResolution ( ) #
Console: render_field_height_resolution
Returns the value indicating the resolution of the FieldHeight.Return value
One of the following values:- 0 - 128 x 128.
- 1 - 256 x 256.
- 2 - 512 x 512 (by default).
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192.
void engine.render.setFieldPrecision ( int precision ) #
Console: render_field_precision
Sets the precision of textures used for field objects.Arguments
- int precision - Textures' precision:
- 0 - 16-bit precision R16 texture (by default).
- 1 - 32-bit precision R32F texture.
int engine.render.isFieldPrecision ( ) #
Console: render_field_precision
Returns the value indicating the current precision of textures used for field objects.Return value
Textures' precision:- 0 - 16-bit precision R16 texture (by default).
- 1 - 32-bit precision R32F texture.
void engine.render.setFieldShorelineResolution ( int resolution ) #
Console: render_field_shoreline_resolution
Set resolution of the texture into which all textures set for all FieldShoreline objects are rendered.Arguments
- int resolution - General FieldShoreline texture resolution:
- 0 - 128 x 128 (by default).
- 1 - 256 x 256.
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192.
int engine.render.getFieldShorelineResolution ( ) #
Console: render_field_shoreline_resolution
Returns resolution of the texture into which all textures set for all FieldShoreline objects are rendered.Return value
General FieldShoreline texture resolution:- 0 - 128 x 128 (by default).
- 1 - 256 x 256.
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192.
void engine.render.setFilmic ( int filmic ) #
Console: render_filmic
Enables or disables the filmic tonemapping effect.Arguments
- int filmic - 1 to enable the filmic tonemapping effect, 0 to disable it. The default value is 1.
int engine.render.isFilmic ( ) #
Console: render_filmic
Returns a value indicating if the filmic tonemapping effect is enabled.Return value
1 if the filmic tonemapping effect is enabled; otherwise, 0.void engine.render.setFilmicLinearAngle ( float angle ) #
Console: render_filmic_linear_angle
Sets the Linear Angle filmic tonemapping parameter value. This parameter controls the slope of the linear part of the tone mapping curve.Arguments
- float angle - Linear Angle value.
float engine.render.getFilmicLinearAngle ( ) #
Console: render_filmic_linear_angle
Returns the current Linear Angle filmic tone mapping parameter value. This parameter controls the slope of the linear part of the tone mapping curve.Return value
Linear Angle value.void engine.render.setFilmicLinearScale ( float scale ) #
Console: render_filmic_linear_scale
Sets the Linear Strength filmic tonemapping parameter value that is used to change gray values. The Linear Scale controls the length of the tone mapping curve linear part.Arguments
- float scale - Linear Strength value.
float engine.render.getFilmicLinearScale ( ) #
Console: render_filmic_linear_scale
Returns the current Linear Strength filmic tone mapping parameter value that is used to change gray values. The Linear Scale controls the length of the tone mapping curve linear part.Return value
Linear Strength value.void engine.render.setFilmicShoulderScale ( float scale ) #
Console: render_filmic_shoulder_scale
Sets the Shoulder Strength filmic tonemapping parameter value that is used to change bright values.Arguments
- float scale - Shoulder Strength value.
float engine.render.getFilmicShoulderScale ( ) #
Console: render_filmic_shoulder_scale
Returns the current Shoulder Strength filmic tonemapping parameter value that is used to change bright values.Return value
Shoulder Strength value.void engine.render.setFilmicToeDenominator ( float denominator ) #
Console: render_filmic_toe_denominator
Sets the Toe Denominator filmic tonemapping parameter value.Arguments
- float denominator - Toe Denominator value.
float engine.render.getFilmicToeDenominator ( ) #
Console: render_filmic_toe_denominator
Returns the current Toe Denominator filmic tonemapping parameter value.Return value
Toe Denominator value.void engine.render.setFilmicToeNumerator ( float numerator ) #
Console: render_filmic_toe_numerator
Sets the Toe Numerator filmic tonemapping parameter value.Arguments
- float numerator - Toe Numerator value.
float engine.render.getFilmicToeNumerator ( ) #
Console: render_filmic_toe_numerator
Sets the Toe Numerator filmic tonemapping parameter value.Return value
Toe Numerator value.void engine.render.setFilmicToeScale ( float scale ) #
Console: render_filmic_toe_scale
Sets the Toe Scale filmic tonemapping parameter value that is used to change dark values. The Toe Scale controls the slope of the tone mapping curve toe (the area of underexposure).Arguments
- float scale - Toe scale value.
float engine.render.getFilmicToeScale ( ) #
Console: render_filmic_toe_scale
Returns the current Toe Scale filmic tonemapping parameter value that is used to change dark values. The Toe Scale controls the slope of the tone mapping curve toe (the area of underexposure).Return value
Toe scale value.void engine.render.setFilmicWhiteLevel ( float level ) #
Console: render_filmic_white_level
Sets the Linear White Point filmic tonemapping parameter value, which is mapped as pure white in the resulted image.Arguments
- float level - Linear White Point value.
float engine.render.getFilmicWhiteLevel ( ) #
Console: render_filmic_white_level
Returns the current Linear White Point filmic tonemapping parameter value.Return value
Linear White Point value.void engine.render.setFilmicSaturationRecovery ( float recovery ) #
Console: render_filmic_saturation_recovery
Sets the color saturation recovery value for the filmic tonemapper.Arguments
- float recovery - Color saturation recovery value to be set, in the [0.0f, 1.0f] range. The default value is 0.75f.
- 0.0f - standard filmic tonemapping, no saturation recovery is performed.
- 1.0f - color saturation is recovered to the full extent.
NoticeWhen the 1.0f value is set specular highlights appear too saturated, so the recommended value is 0.75f
float engine.render.getFilmicSaturationRecovery ( ) #
Console: render_filmic_saturation_recovery
Returns the current color saturation recovery value value for the filmic tonemapper.Return value
Current color saturation recovery value in the [0.0f, 1.0f] range. The default value is 0.75f.- 0.0f - standard filmic tonemapping, no saturation recovery is performed.
- 1.0f - color saturation is recovered to the full extent.
Notice
When the 1.0f value is set specular highlights appear too saturated, so the recommended value is 0.75f
void engine.render.setFirstFrame ( int frame ) #
Sets a value indicating if the first frame should be enabled over the current frame.Arguments
- int frame - 1 to enable the first frame flag, 0 - to disable.
int engine.render.isFirstFrame ( ) #
Returns a value indicating if the first frame is enabled over the current frame.Return value
1 if the first frame flag is enabled; otherwise, 0.int engine.render.isFlipped ( ) #
Return value
1 if the render is flipped; otherwise, 0.void engine.render.setFXAAIntensity ( float intensity ) #
Console: render_fxaa_intensity
Sets the intensity of the FXAA. Intensity specifies the sample offset of FXAA fragment. The higher the value, the more blurred image will be.Arguments
- float intensity - Intensity value of the FXAA to be set.
float engine.render.getFXAAIntensity ( ) #
Console: render_fxaa_intensity
Returns the intensity value of the FXAA. Intensity specifies the sample offset of FXAA fragment.Return value
Intensity value of the FXAAvoid engine.render.setGbufferLightmap ( int lightmap ) #
Console: render_gbuffer_lightmap
Enables or disables storing lightmap data in the GBuffer.Arguments
- int lightmap - 1 to enable storing lightmap data in the GBuffer, 0 to disable it. The default value is 1.
int engine.render.isGbufferLightmap ( ) #
Console: render_gbuffer_lightmap
Returns a value indicating if lightmap data is stored in the GBuffer.Return value
1 if lightmap data is stored in the GBuffer; otherwise, 0.int engine.render.getGPUMemory ( ) #
Console: gpu_memory
Returns an amount of memory provided by the current GPU.Return value
Amount of memory in Mbytes.int engine.render.getGPUName ( ) #
Returns the name of the current GPU.Return value
GPU name flag.Texture engine.render.getGray2DArrayTexture ( ) #
Returns gray 2D array texture.Return value
Gray 2D array texture.Texture engine.render.getGray2DTexture ( ) #
Returns gray 2D texture.Return value
Gray 2D texture.Texture engine.render.getGray3DTexture ( ) #
Returns gray 3D texture.Return value
Gray 3D texture.Texture engine.render.getGrayCubeTexture ( ) #
Returns gray Cube texture.Return value
Gray Cube texture.void engine.render.setLens ( int lens ) #
Console: render_lens
Enables or disables lens flares.Arguments
- int lens - Positive integer to enable lens flares, 0 to disable.
int engine.render.isLens ( ) #
Console: render_lens
Returns a value indicating if lens flares are enabled.Return value
Positive integer if lens flares are enabled; otherwise, 0.void engine.render.setLensColor ( vec4 color ) #
Console: render_lens_color
Sets the color of a lens flares.Arguments
- vec4 color - Color of lens flares.
vec4 engine.render.getLensColor ( ) #
Console: render_lens_color
Returns the color of a lens flare.Return value
Color of a lens flare.void engine.render.setLensDispersion ( vec3 dispersion ) #
Console: render_lens_dispersion
Sets the color displacement for red, green, and blue channels of the lens flares. Can be used to create light dispersion (chromatic aberrations).Arguments
- vec3 dispersion - Lens dispersion displacement per channel. If a negative value is set for a channel, 0 will be used instead.
vec3 engine.render.getLensDispersion ( ) #
Console: render_lens_dispersion
Returns the current color displacement for red, green and blue channels of the lens flares. Can be used to create light dispersion (chromatic aberrations).Return value
Lens dispersion displacement per channel.void engine.render.setLensLength ( float length ) #
Console: render_lens_length
Sets a length indicating if the whole radial lens flare is rendered on the screen or only a part of it. This option controls how lens flares pattern is distributed.Arguments
- float length - Length of the radial lens flare. The provided value is saturated in the range [0.0f; 1.0f].
float engine.render.getLensLength ( ) #
Console: render_lens_length
Returns the current length indicating if the whole radial lens flare is rendered on the screen or only a part of it. This option controls how lens flares pattern is distributed.Return value
Length of the lens flare.void engine.render.setLensRadius ( float radius ) #
Console: render_lens_radius
Sets a radius of the spherical lens flares on the screen.Arguments
- float radius - Radius of the spherical lens flares. The provided value is saturated in the range [0.0f; 1.0f], where 1.0f is a screen-wide radius (a lens flare is not visible).
float engine.render.getLensRadius ( ) #
Console: render_lens_radius
Returns the current radius of the spherical lens flares on the screen.Return value
Radius of the spherical lens flares.void engine.render.setLensScale ( float scale ) #
Console: render_lens_scale
Sets the multiplier for color of HDR lens flares.Arguments
- float scale - Lens color scale. If a negative value is provided, 0.0f will be used instead.
float engine.render.getLensScale ( ) #
Console: render_lens_scale
Returns the current multiplier for color of HDR lens flares.Return value
Lens color scale.void engine.render.setLensThreshold ( float threshold ) #
Console: render_lens_threshold
Sets the brightness threshold for lens flares.Arguments
- float threshold - Lens flares threshold.
float engine.render.getLensThreshold ( ) #
Console: render_lens_threshold
Returns the current brightness threshold for lens flares.Return value
Lens flares threshold.void engine.render.setLightDistance ( float distance ) #
Console: render_light_distance
Sets the distance, at which (and farther) dynamic lights will not be rendered.Arguments
- float distance - Distance in units.
float engine.render.getLightDistance ( ) #
Console: render_light_distance
Returns the distance, at which (and farther) dynamic lights will not be rendered.Return value
Distance in units.void engine.render.setLightsForwardPerObjectEnv ( int env ) #
Console: render_lights_forward_per_object_env
Sets the maximum number of environment probes per object (available only for materials rendered in the forward rendering pass). You should set the nonzero value to increase performance: it is recommended to use not more than 4 environment probes per object.Arguments
- int env - Maximum number of environment probes per object within the [0; 128] range. The default value is 4.
int engine.render.getLightsForwardPerObjectEnv ( ) #
Console: render_lights_forward_per_object_env
Returns the current maximum number of environment probes per object (available only for materials rendered in the forward rendering pass).Return value
Maximum number of environment probes per object within the [0; 128] range.void engine.render.setLightsForwardPerObjectOmni ( int omni ) #
Sets the maximum number of omni lights per object (available only for materials rendered in the forward rendering pass). You should set the nonzero value to increase performance: it is recommended to use not more than 4 omni lights per object.Arguments
- int omni - Maximum number of omni lights per object within the [0; 128] range. The default value is 4.
int engine.render.getLightsForwardPerObjectOmni ( ) #
Returns the current maximum number of omni lights per object (available only for materials rendered in the forward rendering pass).Return value
Maximum number of omni lights per object within the [0; 128] range.void engine.render.setLightsForwardPerObjectProj ( int proj ) #
Sets the maximum number of projected lights per object (available only for materials rendered in the forward rendering pass). You should set the nonzero value to increase performance: it is recommended to use not more than 4 projected lights per object.Arguments
- int proj - Maximum number of projected lights per object within the [0; 128] range. The default value is 4.
int engine.render.getLightsForwardPerObjectProj ( ) #
Returns the current maximum number of projected lights per object (available only for materials rendered in the forward rendering pass).Return value
Maximum number of projected lights per object within the [0; 128] range.void engine.render.setLightsForwardPerObjectVoxel ( int voxel ) #
Sets the maximum number of voxel probes per object (available only for materials rendered in the forward rendering pass). You should set the nonzero value to increase performance: it is recommended to use not more than 4 projected lights per object.Arguments
- int voxel - Maximum number of voxel probes per object within the [0; 128] range.
int engine.render.getLightsForwardPerObjectVoxel ( ) #
Returns the current maximum number of voxel probes per object (available only for materials rendered in the forward rendering pass).Return value
Maximum number of voxel probes per object within the [0; 128] range.void engine.render.setLightsForwardPerObjectWorld ( int world ) #
Sets the maximum number of world lights per object (available only for materials rendered in the forward rendering pass). You should set the nonzero value to increase performance: it is recommended to use not more than 4 world lights per object.Arguments
- int world - Maximum number of world lights per object within the [0; 128] range. The default value is 4.
int engine.render.getLightsForwardPerObjectWorld ( ) #
Returns the current maximum number of world lights per object (available only for materials rendered in the forward rendering pass).Return value
Maximum number of world lights per object within the [0; 128] range.void engine.render.setLightsInterleaved ( int interleaved ) #
Console: render_lights_interleaved
Sets a value indicating if interleaved mode for rendering lights during the deferred pass is enabled. When enabled, lights are rendered in half resolution with subsequent reconstruction of neighboring pixels using the data from previous frames. This mode requires a high framerate (60+ FPS), otherwise anti-aliasing quality reduces and ghosting effect becomes more pronounced. Recommended for relatively static scenes which contain a lot of light sources and do not have a lot of reflective surfaces (in case of small number of light sources may reduce performance).
Arguments
- int interleaved - 1 to enable interleaved lights rendering mode, 0 to disable it.
int engine.render.isLightsInterleaved ( ) #
Console: render_lights_interleaved
Returns a value indicating if interleaved mode for rendering lights during the deferred pass is enabled.Return value
1 if interleaved lights rendering mode is enabled; otherwise, 0.void engine.render.setLightsInterleavedCatmullResampling ( int resampling ) #
Sets a value indicating if the Catmull-Rom resampling for interleaved lights rendering mode is enabled. This mode allows you to reduce image blurring when the camera moves forward/backward.Arguments
- int resampling - 1 to enable the Catmull-Rom resampling for interleaved lights rendering mode, 0 to disable it.
int engine.render.isLightsInterleavedCatmullResampling ( ) #
Returns a value indicating if the Catmull-Rom resampling for interleaved lights rendering mode is enabled.Return value
1 if the Catmull-Rom resampling for interleaved lights rendering mode is enabled; otherwise, 0.void engine.render.setLightsInterleavedColorClamping ( int clamping ) #
Sets the color clamping mode to be used for interleaved lights rendering mode. This mode is used to reduce ghosting effect: higher values increase clamping intensity but may cause flickering on rippled reflective surfaces (as this mode is not so good at object's edges). When disabled, shadows and reflections have a lag as they are several frames behind.Arguments
- int clamping - Color clamping mode to be used, one of the following values:
- 0 - color clamping is disabled
- 1 - low clamping
- 2 - medium clamping
- 3 - high clamping
int engine.render.getLightsInterleavedColorClamping ( ) #
Returns the current color clamping mode used for interleaved lights rendering mode.Return value
Current color clamping mode, one of the following values:- 0 - color clamping is disabled
- 1 - low clamping
- 2 - medium clamping
- 3 - high clamping
void engine.render.setLightsLensFlares ( int flares ) #
Console: render_lights_lens_flares
Enables or disables rendering of per-light lens flares.Arguments
- int flares - 1 to enable rendering of per-light lens flares, 0 to disable it. The default value is 1.
int engine.render.isLightsLensFlares ( ) #
Console: render_lights_lens_flares
Returns the value indicating if rendering of per-light lens flares is enabled.Return value
1 if rendering of per-light lens flares is enabled; otherwise, 0.void engine.render.setLightsMaxPerBatch ( int batch ) #
Console: render_lights_max_per_batch
Sets the maximum number of lights rendered by a tile per batch call.
With lights batching optimization, omni lights divided into tiles are rendered in batches: each tile renders the specified number of lights per batch. It allows decreasing the number of DIP calls and increasing performance. The optimization works only for omni lights with point shape and without shadows.Arguments
- int batch - Maximum number of lights per batch within the [0; 1024] range. The default value is 1024.
Notice0 disables batching optimization.
int engine.render.getLightsMaxPerBatch ( ) #
Console: render_lights_max_per_batch
Returns the current maximum number of lights rendered by a tile per batch call. With lights batching optimization, omni lights divided into tiles are rendered in batches: each tile renders the specified number of lights per batch. It allows decreasing the number of DIP calls and increasing performance. The optimization works only for omni lights with point shape and without shadows.Return value
Maximum number of lights per batch within the [0; 1024] range.Notice
0 means batching optimization is disabled.
void engine.render.setLightsTileGridSize ( int size ) #
Console: render_lights_tile_grid_size
Sets the number of grid tiles per axis for tiled rendering optimization. During this optimization, the screen space is divided into tiles that render lights in batches. The optimization works only for omni lights with point shape and without shadows.Arguments
- int size - Number of grid tiles per axis within the [1; 32] range. The default value is 8.
int engine.render.getLightsTileGridSize ( ) #
Console: render_lights_tile_grid_size
Returns the current number of grid tiles per axis for tiled rendering optimization. During this optimization, the screen space is divided into tiles that render lights in batches. The optimization works only for omni lights with point shape and without shadows.Return value
Number of grid tiles per axis within the [1; 32] range.int engine.render.getMaxFieldAnimations ( ) #
Returns the maximum limit of FieldAnimation nodes allowed to be used in shaders.Return value
Maximum number of FieldAnimation nodes allowed.Notice
Higher values will affect shader compilation time and performance
int engine.render.getMaxFieldHeights ( ) #
Returns the maximum limit of FieldHeight nodes allowed to be used in shaders.Return value
Maximum number of FieldHeight nodes allowed.Notice
Higher values will affect shader compilation time and performance
int engine.render.getMaxFieldShorelines ( ) #
Returns the maximum limit of FieldShoreline nodes allowed to be used in shaders.Return value
Maximum number of FieldShoreline nodes allowed.Notice
Higher values will affect shader compilation time and performance
int engine.render.getMaxFieldSpacers ( ) #
Returns the maximum limit of FieldSpacer nodes allowed to be used in shaders.Return value
Maximum number of FieldSpacer nodes allowed.Notice
Higher values will affect shader compilation time and performance
void engine.render.setMotionBlur ( int blur ) #
Console: render_motion_blur
Enables or disables the motion blur effect.Arguments
- int blur - 1 to enable the motion blur effect, 0 to disable it. The default value is 1.
int engine.render.isMotionBlur ( ) #
Console: render_motion_blur
Returns a value indicating if the motion blur effect is enabled.Return value
1 if the motion blur effect is enabled; otherwise, 0.void engine.render.setMotionBlurCameraVelocity ( int velocity ) #
Console: render_motion_blur_camera_velocity
Sets a value indicating if camera velocity contributes to the motion blur effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int velocity - 1 to take camera velocity into account in the motion blur effect; 0 to take into account velocities of objects only.
int engine.render.isMotionBlurCameraVelocity ( ) #
Console: render_motion_blur_camera_velocity
Returns a value indicating if camera velocity contributes to the motion blur effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 camera velocity contributes to the motion blur effect; 0 only velocities of objects are taken into account in the motion blur effect.void engine.render.setMotionBlurMaxVelocity ( float velocity ) #
Console: render_motion_blur_max_velocity
Sets the maximum possible amount of motion blur for moving physical objects. When their body velocity exceeds the set value, they will be blurred as if they have the maximum velocity set by the parameter.
This parameter should be used:
- To avoid excessive blurring of fast moving objects.
- To save performance, as increasing the object's velocity leads increasing the radius of the motion blur effect that drops performance at too high values.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float velocity - Maximum scaled velocity of moving physical bodies used for the motion blur effect.
float engine.render.getMotionBlurMaxVelocity ( ) #
Console: render_motion_blur_max_velocity
Returns the current maximum possible amount of motion blur for moving physical objects.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Maximum scaled velocity of moving physical bodies used for the motion blur effect.void engine.render.setMotionBlurNeatSilhouettes ( int silhouettes ) #
Console: render_motion_blur_neat_silhouettes
Enables or disables the neat silhouettes option for motion blur. This option keeps contours of objects in front of the camera unblurred.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int silhouettes - 1 to enable the neat silhouettes option for motion blur, 0 to disable it. The default value is 1.
int engine.render.isMotionBlurNeatSilhouettes ( ) #
Console: render_motion_blur_neat_silhouettes
Returns a value indicating if neat silhouettes option for motion blur is enabled. This option keeps contours of objects in front of the camera unblurred.Return value
1 if the neat silhouettes option is enabled; otherwise, 0.void engine.render.setMotionBlurNoiseIntensity ( float intensity ) #
Console: render_motion_blur_noise_intensity
Sets the intensity of the noise used in the motion blur.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Noise intensity value within the [0.0f; 1.0f] range. The default value is 0.25f.
float engine.render.getMotionBlurNoiseIntensity ( ) #
Console: render_motion_blur_noise_intensity
Returns the current intensity of the noise used in the motion blur.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Noise intensity.void engine.render.setMotionBlurNumSteps ( int steps ) #
Console: render_motion_blur_num_steps
Sets the number of steps used in the motion blur. The higher the value, the more correct the motion blur effect is. At low values, moving objects may look doubled, however, performance will increase.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int steps - Number of steps in range [2;64]. The default value is 4.
int engine.render.getMotionBlurNumSteps ( ) #
Console: render_motion_blur_num_steps
Returns the current number of steps used in the motion blur. The higher the value, the more correct the motion blur effect is. At low values, moving objects may look doubled, however, performance will increase.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Number of steps.void engine.render.setMotionBlurVelocityScale ( float scale ) #
Console: render_motion_blur_velocity_scale
Sets amount of motion blur for moving physical bodies. The higher the value, the more blurred the objects will appear when moving.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float scale - Scale of bodies' linear and angular velocities used for the motion blur. If a negative value is provided, 0 will be used instead.
float engine.render.getMotionBlurVelocityScale ( ) #
Console: render_motion_blur_velocity_scale
Returns the current amount of motion blur for moving physical bodies. The higher the value, the more blurred the objects will appear when moving.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Scale of bodies' linear and angular velocities used for the motion blur.int engine.render.getNumDecals ( ) #
Returns the number of rendered per frame decals that can be currently seen in the viewport (during all of the rendering passes).Return value
The number of decals.int engine.render.getNumDips ( ) #
Returns the number of draw calls used in the current scene. See Rendering Profiler article for details.Return value
The number of draw calls.int engine.render.getNumInstances ( ) #
Returns the maximum number of instances that can be rendered for each of the following node types:Notice
Returned value depends on the graphics API used.
Return value
Maximum number of instances that can be rendered.int engine.render.getNumLights ( ) #
Returns the number of light passes rendered per frame. It means that the value contains the number of all light sources that are currently seen illuminating something in the viewport and also includes additional passes for rendering lights in the reflecting surfaces (if dynamical reflections are used). See Rendering Profiler article for details.Return value
The number of light passes.int engine.render.getNumMaterials ( ) #
Returns the number of materials set per frame (during all of the rendering passes) in the current scene.Return value
The number of materials.int engine.render.getNumPrimitives ( ) #
Returns the number of geometric rendered per frame primitives that can be currently seen in the viewport. See Rendering Profiler article for details.Return value
The number of primitives.int engine.render.getNumProcedurals ( ) #
Returns the number of procedurals that can be currently seen in the viewport.Return value
The number of procedurals.int engine.render.getNumReflections ( ) #
Returns the number of reflections drawn per frame that can be currently seen in the viewport. In case of cubemap reflections, if all six faces are updated, six reflections are rendered per each frame.Return value
The number of reflections.long engine.render.getNumShaders ( ) #
Returns the number of shaders set per frame. See Rendering Profiler article for details.Return value
The number of shaders.int engine.render.getNumShadows ( ) #
Returns the number of shadow passes rendered per frame. See Rendering Profiler article for details.Return value
The number of shadow passes.int engine.render.getNumSurfaces ( ) #
Returns the number of rendered per frame surfaces that can be currently seen in the viewport (in all rendering passes). See Rendering Profiler article for details.Return value
Number of surfaces.int engine.render.getNumTriangles ( ) #
Returns the number of rendered per frame triangles that can be currently seen in the viewport. See Rendering Profiler article for details.Return value
Number of triangles.void engine.render.setObjectDistance ( float distance ) #
Console: render_object_distance
Sets the distance, at which (and farther) objects will not be rendered.Arguments
- float distance - Distance in units.
float engine.render.getObjectDistance ( ) #
Console: render_object_distance
Returns a distance, at which (and farther) objects will not be rendered.Return value
Distance in units.void engine.render.setOccluders ( int occluders ) #
Console: render_occluders
Enables or disables rendering of occluders.Arguments
- int occluders - 1 to enable rendering of occluders, 0 to disable it. The default value is 1.
int engine.render.isOccluders ( ) #
Console: render_occluders
Returns a value indicating if rendering of occluders is enabled.Return value
1 if rendering of occluders is enabled; otherwise, 0. The default value is 1.void engine.render.setOccludersResolution ( vec2 resolution ) #
Console: render_occluders_resolution
Sets the resolution of the texture, to which occluders are rendered.Arguments
- vec2 resolution - Texture resolution (X, Y), in pixels. Available values are from (1, 1) to (1024, 1024). The default value is (128, 64).
vec2 engine.render.getOccludersResolution ( ) #
Console: render_occluders_resolution
Returns the current resolution of the texture, to which occluders are rendered.Return value
Texture resolution (X, Y), in pixels. Available values are from (1, 1) to (1024, 1024). The default value is (128, 64).void engine.render.setOccludersShadows ( int shadows ) #
Console: render_occluders_shadows
Sets the value indicating whether rendering of occluders for shadows is enabled.Arguments
- int shadows - 1 to enable rendering of occluders for shadows, 0 to disable it. The default value is 0.
int engine.render.isOccludersShadows ( ) #
Console: render_occluders_shadows
Returns the value indicating whether rendering of occluders for shadows is enabled.Return value
1 if rendering of occluders for shadows is enabled; otherwise, 0. The default value is 0.void engine.render.setOccludersShadowsResolution ( vec2 resolution ) #
Console: render_occluders_shadows_resolution
Sets the resolution of the texture, to which occluders for shadows are rendered.Arguments
- vec2 resolution - Texture resolution (X, Y), in pixels. Available values are from (1, 1) to (1024, 1024). The default value is (512, 512).
vec2 engine.render.getOccludersShadowsResolution ( ) #
Console: render_occluders_shadows_resolution
Returns the current resolution of the texture, to which occluders for shadows are rendered.Return value
Texture resolution (X, Y), in pixels. Available values are from (1, 1) to (1024, 1024). The default value is (512, 512).void engine.render.setOcclusionQueries ( int queries ) #
Console: render_occlusion_queries
Enables or disables additional hardware occlusion query test before sending data to GPU.Arguments
- int queries - 1 to enable additional hardware occlusion query test, 0 to disable it. The default value is 1.
int engine.render.isOcclusionQueries ( ) #
Console: render_occlusion_queries
Returns a value indicating if additional hardware occlusion query test before sending data to GPU is enabled.Return value
1 if if additional hardware occlusion query test is enabled; otherwise, 0.void engine.render.setOcclusionQueriesNumFrames ( int frames ) #
Console: render_occlusion_queries_num_frames
Sets the number of frames for additional hardware occlusion query test performed before sending data to GPU.Arguments
- int frames - Number of frames. The value within the [0; 1024] range. The default value is 5.
int engine.render.getOcclusionQueriesNumFrames ( ) #
Console: render_occlusion_queries_num_frames
Returns the current number of frames for additional hardware occlusion query test performed before sending data to GPU.Return value
Number of frames. The value within the [0; 1024] range.void engine.render.setPostMaterials ( string materials ) #
Sets post postprocess materials that are applied after all other postprocess (such as HDR, DoF, etc.) are rendered. Materials are applied in the order of listing. They are used together with Player::setPostMaterials(), if any.Arguments
- string materials - Comma-separated list of post postprocess material names.
string engine.render.getPostMaterials ( ) #
Returns names of the current post postprocess materials that are applied after all other postprocess (such as HDR, DoF, etc.) are rendered. Materials are applied in the order of listing. They are used together with Player::getPostMaterials(), if any.Return value
Comma-separated list of current post postprocess material names.void engine.render.setReflectionDistance ( float distance ) #
Console: render_reflection_distance
Sets the distance, at which (and farther) reflections will not be rendered.Arguments
- float distance - Distance in units.
float engine.render.getReflectionDistance ( ) #
Console: render_reflection_distance
Returns the distance, at which (and farther) reflections will not be rendered.Return value
Distance in units.void engine.render.setReflectionDynamic ( int dynamic ) #
Console: render_reflection_dynamic
Enables or disables dynamic reflections for materials.Arguments
- int dynamic - 1 to enable dynamic reflections for materials, 0 to disable it. The default value is 1.
int engine.render.isReflectionDynamic ( ) #
Console: render_reflection_dynamic
Returns a value indicating if dynamic reflections for materials are enabled.Return value
1 if dynamic reflections for materials are enabled; otherwise, 0.void engine.render.setReflectionLods ( int lods ) #
Console: render_reflection_lods
Enables or disables reduction of resolution of dynamic reflections when the camera moves away.Arguments
- int lods - 1 to enable reduction of resolution of dynamic reflections when the camera moves away, 0 to disable it. The default value is 1.
int engine.render.isReflectionLods ( ) #
Console: render_reflection_lods
Returns a value indicating if reduction of resolution of dynamic reflections when the camera moves away is enabled.Return value
1 if reduction of resolution of dynamic reflections when the camera moves away is enabled; otherwise, 0.void engine.render.setRefraction ( int refraction ) #
Console: render_refraction
Enables or disables refraction.Arguments
- int refraction - 1 to enable refraction, 0 to disable it. The default value is 1.
int engine.render.isRefraction ( ) #
Console: render_refraction
Returns a value indicating if refraction is enabled.Return value
1 if refraction is enabled; otherwise, 0.void engine.render.setRefractionDispersion ( vec3 dispersion ) #
Console: render_refraction_dispersion
Sets the refraction displacement for red, green and blue channels (according to refraction texture of refractive materials). Can be used to create light dispersion (chromatic aberrations).Arguments
- vec3 dispersion - Dispersion displacement per channel. If a negative value is set for a channel, 0 will be used instead.
vec3 engine.render.getRefractionDispersion ( ) #
Console: render_refraction_dispersion
Returns the refraction displacement for red, green and blue channels (according to the refraction texture of refractive materials). It can be used to create light dispersion (chromatic aberrations).Return value
Dispersion displacement.void engine.render.setPrePostMaterials ( string materials ) #
Sets pre-post materials that are applied before all other postprocess (such as HDR, DoF, etc.) are rendered. Materials are applied in the order of listing.Arguments
- string materials - List of comma-separated pre-post material names.
string engine.render.getPrePostMaterials ( ) #
Returns names of the current pre-post materials that are applied before all other postprocess (such as HDR, DoF, etc.) are rendered. Materials are applied in the order of listing.Return value
Name of the current pre-post materials.void engine.render.setScreenPrecision ( int precision ) #
Console: render_screen_precision
Sets screen precision. This parameter determines the texture format used for screen HDR buffers.Arguments
- int precision - One of the following values:
- 0 - RG11B10F.
- 1 - RGBA16F (by default).
int engine.render.isScreenPrecision ( ) #
Console: render_screen_precision
Returns a value indicating the current screen precision. This parameter determines the texture format used for screen HDR buffers.Return value
One of the following values:- 0 - RG11B10F.
- 1 - RGBA16F (by default).
void engine.render.setShaderDefines ( string defines ) #
Console: render_defines
Set additional shader defines.Arguments
- string defines - Additional shader defines.
string engine.render.getShaderDefines ( ) #
Console: render_defines
Returns additional shader defines.Return value
Additional shader defines.void engine.render.setShadowDistance ( float distance ) #
Console: render_shadows_distance
Sets the distance, at which (and farther) shadows will not be rendered.Arguments
- float distance - Distance in units.
float engine.render.getShadowDistance ( ) #
Console: render_shadows_distance
Returns the distance, at which (and farther) shadows will not be rendered.Return value
Distance in units.void engine.render.setShadows ( int shadows ) #
Console: render_shadows
Enables or disables shadows rendering.Arguments
- int shadows - 1 to enable shadows rendering, 0 to skip it. The default value is 1.
int engine.render.isShadows ( ) #
Console: render_shadows
Returns a value indicating whether shadows are rendered or not.Return value
1 if shadows are rendered; otherwise, 0.void engine.render.setShadowsAlphaTest ( int test ) #
Console: render_shadows_alpha_test
Enables or disables alpha test for shadows.Arguments
- int test - 1 to enable alpha test for shadows, 0 to disable it. The default value is 1.
int engine.render.isShadowsAlphaTest ( ) #
Console: render_shadows_alpha_test
Returns a value indicating if alpha test is enabled for shadows.Return value
1 if alpha test is enabled for shadows; otherwise, 0.void engine.render.setShadowShafts ( int shafts ) #
Console: render_shadow_shafts
Enables or disables volumetric shadows.Arguments
- int shafts - 1 to enable volumetric shadows, 0 to disable. The default value is 0.
int engine.render.isShadowShafts ( ) #
Console: render_shadow_shafts
Returns a value indicating if volumetric shadows are enabled.Return value
1 if volumetric shadows are enabled; otherwise, 0.void engine.render.setShadowShaftsExposure ( float exposure ) #
Console: render_shadow_shafts_exposure
Sets the contrast used for volumetric shadows.Arguments
- float exposure - Shadow contrast. The provided value will be saturated in the range [0.0f; 1.0f]. 0.0f means that the shadows are not seen at all.
float engine.render.getShadowShaftsExposure ( ) #
Console: render_shadow_shafts_exposure
Returns the contrast used for volumetric shadows.Return value
Shadow contrast.void engine.render.setShadowShaftsLength ( float length ) #
Console: render_shadow_shafts_length
Sets the length of volumetric shadows.Arguments
- float length - Shadow length. The provided value will be saturated in the range [0.0f; 1.0f]. 0.0f means that there are no shadows. 1 means that the shadows are long enough to occupy the whole screen.
float engine.render.getShadowShaftsLength ( ) #
Console: render_shadow_shafts_length
Returns the length of volumetric shadows.Return value
Shadow length.void engine.render.setShadowsScreenSpace ( int space ) #
Console: render_shadows_screenspace
Enables or disables screen space shadows. They provide high-quality penumbra, per-light work, per-pixel detail at any zoom level and infinite visibility distance (when enabled, distant objects can cast shadows next to the horizon). Supports depth cutout parallax. Screen space shadows can be mixed with regular ones.Arguments
- int space - 1 to enable screen space shadows, 0 to disable. The default value is 1.
int engine.render.isShadowsScreenSpace ( ) #
Console: render_shadows_screenspace
Returns the value indicating if screen space shadows are enabled. They provide high-quality penumbra, per-light work, per-pixel detail at any zoom level and infinite visibility distance (when enabled, distant objects can cast shadows next to the horizon). Supports depth cutout parallax. Screen space shadows can be mixed with regular ones.Return value
1 if screen space shadows are enabled; otherwise, 0.void engine.render.setShadowsPenumbraMode ( int mode ) #
Console: render_shadows_penumbra_mode
Sets the global quality mode to be used for rendering penumbra from all light sources by default. This mode enables simulation of real-world shadows by keeping sharp contact shadows closer to the base and softening the farther the shadow stretches away. Higher values produce softer shadows.
Notice
You can set penumbra quality mode or disable penumbra rendering for each light source individually.
Arguments
- int mode - Global quality mode to be used for rendering penumbra from all light sources:
- 0 - penumbra rendering is disabled, shadow edges are crisp and sharp (no shadow softness at all).
- 1 — low quality
- 2 — medium quality
- 3 — high quality
- 4 — ultra quality
int engine.render.getShadowsPenumbraMode ( ) #
Console: render_shadows_penumbra_mode
Returns the global quality mode currently used for rendering penumbra from all light sources by default. This mode enables simulation of real-world shadows by keeping sharp contact shadows closer to the base and softening the farther the shadow stretches away. Higher values produce softer shadows.
Notice
You can set penumbra quality mode or disable penumbra rendering for each light source individually.
Return value
Global quality mode currently used for rendering penumbra from all light sources:- 0 - penumbra rendering is disabled, shadow edges are crisp and sharp (no shadow softness at all).
- 1 — low quality
- 2 — medium quality
- 3 — high quality
- 4 — ultra quality
void engine.render.setShadowsPenumbraNoise ( int noise ) #
Console: render_shadows_penumbra_noise
Enables or disables noise for penumbra rendering. This noise is used for smoothing.Arguments
- int noise - 1 to enable noise for penumbra rendering, 0 to disable. The default value is 1.
int engine.render.isShadowsPenumbraNoise ( ) #
Console: render_shadows_penumbra_noise
Returns a value indicating if noise for penumbra rendering is enabled. This noise is used for smoothing.Return value
1 if noise for penumbra rendering is enabled; otherwise, 0.void engine.render.setShadowsFilterMode ( int mode ) #
Console: render_shadows_filter_mode
Sets the global filtering mode to be used for shadows from all light sources by default. This mode determines quality of soft shadows. Higher quality produces smoother shadow edges.
Notice
You can set filtering mode or disable filtering for each light source individually.
Arguments
- int mode - Global filtering mode to be used for shadows from all light sources:
- 0 - filtering for shadows is disabled, the stair-step effect is clearly seen at the edges of shadows.
- 1 — low quality
- 2 — medium quality
- 3 — high quality
- 4 — ultra quality
int engine.render.getShadowsFilterMode ( ) #
Console: render_shadows_filter_mode
Returns the global filtering mode currently used for shadows from all light sources by default. This mode determines quality of soft shadows, it is used to reduce the stair-step effect making the edges smoother. Higher quality produces smoother shadow edges.
Notice
You can set filtering mode or disable filtering for each light source individually.
Return value
Global filtering mode currently used for shadows from all light sources:- 0 - filtering for shadows is disabled, the stair-step effect is clearly seen at the edges of shadows.
- 1 — low quality
- 2 — medium quality
- 3 — high quality
- 4 — ultra quality
void engine.render.setShadowsFilterNoise ( int noise ) #
Console: render_shadows_filter_noise
Enables or disables noise for shadow filtering. This noise is used for smoothing.Arguments
- int noise - 1 to enable noise for shadow filtering, 0 to disable. The default value is 1.
int engine.render.isShadowsFilterNoise ( ) #
Console: render_shadows_filter_noise
Returns a value indicating if noise for shadow filtering is enabled. This noise is used for smoothing.Return value
1 if noise for shadow filtering is enabled; otherwise, 0.void engine.render.setShadowsTranslucentDepth ( float depth ) #
Console: render_shadows_translucent_depth
Sets the global translucence depth value defining how deep the light goes through translucent objects shifting the shadow.Arguments
- float depth - Global translucence depth to be used. The higher the value, the deeper the light penetrates translucent objects shifting the shadow.
float engine.render.getShadowsTranslucentDepth ( ) #
Console: render_shadows_translucent_depth
Returns the global translucence depth value defining how deep the light goes through translucent objects shifting the shadow.Return value
Current global translucence depth value. The higher the value, the deeper the light penetrates translucent objects shifting the shadow.void engine.render.setShadowsWorldLerpCascades ( int cascades ) #
Console: render_shadows_world_lerp_cascades
Enables or disables shadows cascades lerp.Arguments
- int cascades - 1 to enable shadows cascades lerp, 0 to disable it. The default value is 1.
int engine.render.isShadowsWorldLerpCascades ( ) #
Console: render_shadows_world_lerp_cascades
Returns the value indicating if shadows cascades lerp is enabled.Return value
1 if shadows cascades lerp is enabled; otherwise, 0.void engine.render.setSharpen ( int sharpen ) #
Console: render_sharpen
Enables or disables the sharpening post-processing effect.Arguments
- int sharpen - 1 to enable the sharpening post-processing effect, 0 to disable it. The default value is 0.
int engine.render.isSharpen ( ) #
Console: render_sharpen
Returns a value indicating if the sharpening post-processing effect is enabled.Return value
1 if the sharpening post-processing effect is enabled; otherwise, 0.void engine.render.setSharpenIntensity ( float intensity ) #
Console: render_sharpen_intensity
Sets intensity of the sharpening effect.Arguments
- float intensity - Intensity of the sharpening effect.
float engine.render.getSharpenIntensity ( ) #
Console: render_sharpen_intensity
Returns intensity of the sharpening effect.Return value
Intensity of the sharpening effect.void engine.render.setShowAlphaTest ( int test ) #
Console: render_show_alpha_test
Displays or hides the visualizer for transparent objects using alpha test. This parameter is stored in the following configuration file: Arguments
- int test - 1 to display the visualizer for transparent objects using alpha test, 0 to hide it. The default value is 0.
int engine.render.isShowAlphaTest ( ) #
Console: render_show_alpha_test
Returns a value indicating whether the visualizer is displayed for transparent objects using alpha test or not. This parameter is stored in the following configuration file: Return value
1 if visualizer for transparent objects using alpha test is displayed; otherwise, 0.void engine.render.setShowAmbient ( int ambient ) #
Console: render_show_ambient
Enables or disables displaying the ambient pass buffer. This parameter is stored in the following configuration file: Arguments
- int ambient - 1 to display the ambient pass buffer, 0 to hide it. The default value is 0.
int engine.render.isShowAmbient ( ) #
Console: render_show_ambient
Returns a value indicating whether the ambient pass buffer is displayed or not. This parameter is stored in the following configuration file: Return value
1 if the ambient pass buffer is displayed; otherwise, 0.void engine.render.setShowCascades ( int cascades ) #
Console: render_show_cascades
Displays or hides world shadow cascades. This parameter is stored in the following configuration file: Arguments
- int cascades - 1 to display world shadow cascades, 0 to hide them. The default value is 0.
int engine.render.isShowCascades ( ) #
Console: render_show_cascades
Returns a value indicating whether world shadow cascades are displayed or not. This parameter is stored in the following configuration file: Return value
1 if world shadow cascades are displayed; otherwise, 0.void engine.render.setShowDecals ( int decals ) #
Console: render_show_decals
Displays or hides the visualizer for decals. This parameter is stored in the following configuration file: Arguments
- int decals - 1 to display the visualizer for decals, 0 to hide it. The default value is 0.
int engine.render.isShowDecals ( ) #
Console: render_show_decals
Returns a value indicating whether the visualizer is displayed for decals or not. This parameter is stored in the following configuration file: Return value
1 if visualizer for decals is displayed; otherwise, 0.void engine.render.setShowDynamic ( int dynamic ) #
Console: render_show_dynamic
Displays or hides the visualizer for dynamic objects. This parameter is stored in the following configuration file: Arguments
- int dynamic - 1 to display the visualizer for dynamic objects, 0 to hide it. The default value is 0.
int engine.render.isShowDynamic ( ) #
Console: render_show_dynamic
Returns a value indicating whether the visualizer is displayed for dynamic objects or not. This parameter is stored in the following configuration file: Return value
1 if visualizer for dynamic objects is displayed; otherwise, 0.void engine.render.setShowGeodeticPivot ( int pivot ) #
Console: render_show_geodetic_pivot
Displays or hides geodetic pivots. This parameter is stored in the following configuration file: Arguments
- int pivot - 1 to display geodetic pivots, 0 to hide them. The default value is 0.
int engine.render.isShowGeodeticPivot ( ) #
Console: render_show_geodetic_pivot
Returns a value indicating whether geodetic pivots are displayed or not. This parameter is stored in the following configuration file: Return value
1 if geodetic pivots are displayed; otherwise, 0.void engine.render.setShowMipmaps ( int mipmaps ) #
Console: render_show_mipmaps
Displays or hides texture mipmap levels. This parameter is stored in the following configuration file: Arguments
- int mipmaps - 1 to display texture mipmap levels, 0 to hide them. The default value is 0.
int engine.render.isShowMipmaps ( ) #
Console: render_show_mipmaps
Returns a value indicating whether texture mipmap levels are displayed or not. This parameter is stored in the following configuration file: Return value
1 if texture mipmap levels are displayed; otherwise, 0.void engine.render.setShowOccluder ( int occluder ) #
Console: render_show_occluder
Displays or hides the buffer used for occluders. This parameter is stored in the following configuration file: Arguments
- int occluder - 1 to display the buffer used for occluders, 0 to hide it. The default value is 0.
int engine.render.isShowOccluder ( ) #
Console: render_show_occluder
Returns a value indicating whether the buffer used for occluders is displayed in the viewport or not. This parameter is stored in the following configuration file: Return value
1 if the buffer used for occluders is displayed; otherwise, 0.void engine.render.setShowQueries ( int queries ) #
Console: render_show_queries
Displays or hides occlusion query boxes. This parameter is stored in the following configuration file: Arguments
- int queries - 1 to display occlusion query boxes, 0 to hide them. The default value is 0.
int engine.render.isShowQueries ( ) #
Console: render_show_queries
Returns a value indicating whether occlusion query boxes are displayed in the viewport or not. This parameter is stored in the following configuration file: Return value
1 if occlusion query boxes are displayed; otherwise, 0.void engine.render.setShowScissors ( int scissors ) #
Console: render_show_scissors
Displays or hides scissor rectangles. This parameter is stored in the following configuration file: Arguments
- int scissors - 1 to display scissor rectangles, 0 to hide them. The default value is 0.
int engine.render.isShowScissors ( ) #
Console: render_show_scissors
Returns a value indicating if scissor rectangles are displayed. This parameter is stored in the following configuration file: Return value
1 if scissor rectangles are displayed; otherwise, 0.void engine.render.setShowTextures ( int textures ) #
Console: render_show_textures
Sets the display mode for buffers used by the renderer. This parameter is stored in the following configuration file: Arguments
- int textures - One of the following values:
- 0 - hide all buffers (by default).
- 1 - display render textures in a compact view.
- 2 - display render textures in a full view.
int engine.render.getShowTextures ( ) #
Console: render_show_textures
Returns the current display mode for buffers used by the renderer. This parameter is stored in the following configuration file: Return value
One of the following values:- 0 - all buffers are hidden (by default).
- 1 - render textures are displayed in a compact view.
- 2 - render textures are displayed in a full view.
void engine.render.setShowTexturesNumber ( int number ) #
Console: render_show_textures_number
Sets the number of buffers in a row displayed in the full view mode (see setShowTextures(2)). This parameter is stored in the following configuration file: Arguments
- int number - Number of buffers in a row. Value within the [1; 16] range. The default value is 7.
int engine.render.getShowTexturesNumber ( ) #
Console: render_show_textures_number
Returns the current number of buffers in a row displayed in the full view mode (see setShowTextures(2)). This parameter is stored in the following configuration file: Return value
Number of buffers in a row.void engine.render.setShowTexturesOffset ( int offset ) #
Console: render_show_textures_offset
Sets the number of the buffer to start displaying from in the full view mode (see setShowTextures(2)). This parameter is stored in the following configuration file: Arguments
- int offset - Number of the buffer to start displaying from. Value within the [0; 52] range. The default value is 0.
int engine.render.getShowTexturesOffset ( ) #
Console: render_show_textures_offset
Returns the current number of the buffer to start displaying from in the full view mode (see setShowTextures(2)). This parameter is stored in the following configuration file: Return value
Number of the buffer to start displaying from. Value within the [0; 52] range.void engine.render.setShowTransparent ( int transparent ) #
Console: render_show_transparent
Displays or hides the visualizer for transparent objects. This parameter is stored in the following configuration file: Arguments
- int transparent - 1 to display the visualizer for transparent objects, 0 to hide it. The default value is 0.
int engine.render.isShowTransparent ( ) #
Console: render_show_transparent
Returns a value indicating whether the visualizer is displayed for transparent objects or not. This parameter is stored in the following configuration file: Return value
1 if visualizer for transparent objects is enabled; otherwise, 0.void engine.render.setShowTriangles ( int triangles ) #
Console: render_show_triangles
Sets the wireframe mode for scene triangles. This parameter is stored in the following configuration file: Arguments
- int triangles - One of the following values:
- 0 - triangles are hidden (by default).
- 1 - front faces with the depth test are shown.
- 2 - front faces without the depth test are shown.
- 3 - front and back faces without the depth test are shown.
int engine.render.getShowTriangles ( ) #
Console: render_show_triangles
Returns the current wireframe mode for scene triangles. This parameter is stored in the following configuration file: Return value
One of the following values:- 0 - triangles are hidden (by default).
- 1 - front faces with the depth test are shown.
- 2 - front faces without the depth test are shown.
- 3 - front and back faces without the depth test are shown.
void engine.render.setCloudsEnabled ( int enabled ) #
Console: render_clouds_enabled
Enables or disables clouds rendering.Arguments
- int enabled - 0 to skip rendering of clouds, 1 to render clouds. The default value is 1.
int engine.render.isCloudsEnabled ( ) #
Console: render_clouds_enabled
Returns a value indicating if rendering of clouds is enabled.Return value
1 if rendering of clouds is enabled; otherwise, 0.void engine.render.setLightsEnabled ( int enabled ) #
Console: render_lights_enabled
Enables or disables lights rendering.Arguments
- int enabled - 0 to skip rendering of lights, 1 to render lights. The default value is 1.
int engine.render.isLightsEnabled ( ) #
Console: render_lights_enabled
Returns a value indicating if rendering of lights is enabled.Return value
1 if rendering of lights is enabled; otherwise, 0.void engine.render.setWaterEnabled ( int enabled ) #
Console: render_water_enabled
Enables or disables water rendering.Arguments
- int enabled - 0 to skip rendering of water, 1 to render water. The default value is 1.
int engine.render.isWaterEnabled ( ) #
Console: render_water_enabled
Returns a value indicating if rendering of water is enabled.Return value
1 if rendering of water is enabled; otherwise, 0.void engine.render.setScreenSpaceEffects ( int effects ) #
Console: render_screen_space_effects
Enables or disables rendering of screen-space effects.Arguments
- int effects - 1 to enable rendering of screen-space effects, 1 to skip them. The default value is 1.
int engine.render.isScreenSpaceEffects ( ) #
Console: render_screen_space_effects
Returns a value indicating if rendering of screen-space effects is enabled.Return value
1 if rendering of screen-space effects is enabled; otherwise, 0.void engine.render.setPrePostMaterialsEnabled ( int enabled ) #
Console: render_pre_post_materials_enabled
Enables or disables rendering of pre-post materials (post-process materials applied before all other Unigine post-processes).Arguments
- int enabled - 1 to render pre-post materials, 0 to skip them. The default value is 1.
int engine.render.isPrePostMaterialsEnabled ( ) #
Console: render_pre_post_materials_enabled
Returns a value indicating if rendering of pre-post materials (post-process materials applied before all other Unigine post-processes) is enabled.Return value
1 if rendering of pre-post materials is enabled; otherwise, 0.void engine.render.setTransparentEnabled ( int enabled ) #
Console: render_transparent_enabled
Enables or disables rendering of the transparent pass.Arguments
- int enabled - 1 to render the transparent pass, 0 to skip it. The default value is 1.
int engine.render.isTransparentEnabled ( ) #
Console: render_transparent_enabled
Returns a value indicating if the transparent pass is rendered.Return value
1 if the transparent pass is rendered; otherwise, 0.void engine.render.setTransparentAmbient ( int ambient ) #
Console: render_transparent_ambient
Enables or disables rendering of the transparent ambient pass.Arguments
- int ambient - 1 to render the transparent ambient pass, 0 to skip it. The default value is 1.
int engine.render.isTransparentAmbient ( ) #
Console: render_transparent_ambient
Returns a value indicating if the transparent ambient pass is rendered.Return value
1 if the transparent ambient pass is rendered; otherwise, 0.void engine.render.setTransparentDeferred ( int deferred ) #
Console: render_transparent_deferred
Enables or disables rendering of the transparent deferred pass.Arguments
- int deferred - 1 to render the transparent deferred pass, 0 to skip it. The default value is 1.
int engine.render.isTransparentDeferred ( ) #
Console: render_transparent_deferred
Returns a value indicating if the transparent deferred pass is rendered.Return value
1 if the transparent deferred pass is rendered; otherwise, 0.void engine.render.setTransparentLight ( int light ) #
Console: render_transparent_light
Enables or disables rendering of the transparent light pass.Arguments
- int light - 1 to render the transparent light pass, 0 to skip it. The default value is 1.
int engine.render.isTransparentLight ( ) #
Console: render_transparent_light
Returns a value indicating if the transparent light pass is rendered.Return value
1 if the transparent light pass is rendered; otherwise, 0.void engine.render.setTransparentMultipleEnvProbes ( int probes ) #
Enables or disables rendering of the transparent multiple environment probes pass.Arguments
- int probes - 1 to render the transparent multiple environment probes pass, 0 to skip it. The default value is 1.
int engine.render.isTransparentMultipleEnvProbes ( ) #
Returns a value indicating if the transparent multiple environment probes pass is rendered.Return value
1 if the transparent multiple environment probes pass is rendered; otherwise, 0.void engine.render.setSkyRotation ( quat rotation ) #
Sets sky rotation.Arguments
- quat rotation - Sky rotation quaternion.
quat engine.render.getSkyRotation ( ) #
Returns sky rotation.Return value
Sky rotation quaternion.void engine.render.setSSAO ( int ssao ) #
Console: render_ssao
Enables or disables the SSAO (Screen Space Ambient Occlusion) effect.Arguments
- int ssao - 1 to enable the SSAO effect, 0 to disable.
int engine.render.isSSAO ( ) #
Console: render_ssao
Returns the value indicating if the SSAO (Screen Space Ambient Occlusion) effect is enabled.Return value
1 if the SSAO effect is enabled; otherwise, 0.void engine.render.setSSAOCavity ( int cavity ) #
Console: render_ssao_cavity
Enables or disables the cavity option for the SSAO (Screen Space Ambient Occlusion) effect. This option improves (sharpens) the look of junction contours at low resolutions, so it should be used for detail enhancement (small stones, bolts and so on).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int cavity - 1 to enable the cavity option for the SSAO effect, 0 to disable. The default value is 1.
int engine.render.isSSAOCavity ( ) #
Console: render_ssao_cavity
Returns the value indicating if the cavity option for the SSAO (Screen Space Ambient Occlusion) effect is enabled. This option improves (sharpens) the look of junction contours at low resolutions, so it should be used for detail enhancement (small stones, bolts and so on).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the cavity option for the SSAO effect is enabled; otherwise, 0.void engine.render.setSSAOCavityIntensity ( float intensity ) #
Console: render_ssao_cavity_intensity
Sets the intensity of sharpening of contours for the cavity option (see the setSSAOCavity() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Sharpening intensity value. The default value is 1.0f.
float engine.render.getSSAOCavityIntensity ( ) #
Console: render_ssao_cavity_intensity
Returns the intensity of sharpening of contours for the cavity option (see the setSSAOCavity() method).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Sharpening intensity value. The default value is 1.0f.void engine.render.setSSAOCavityRadius ( float radius ) #
Console: render_ssao_cavity_radius
Sets the size of junction contours area for the cavity option (see the setSSAOCavity() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float radius - Size of junction contours area. The default value is 1.0f.
float engine.render.getSSAOCavityRadius ( ) #
Console: render_ssao_cavity_radius
Returns the size of junction contours area for the cavity option (see the setSSAOCavity() method).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Size of junction contours area. The default value is 1.0f.void engine.render.setSSAOIntensity ( float intensity ) #
Console: render_ssao_intensity
Sets the intensity of the SSAO (Screen Space Ambient Occlusion) for the scene. The intensity value affects brightness of shadows:
- By the minimum value of 0.0f, the ambient occlusion shadowing is the lightest.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Intensity value of the SSAO (Screen Space Ambient Occlusion) for the scene. The default value is 1.0f.
float engine.render.getSSAOIntensity ( ) #
Console: render_ssao_intensity
Returns the intensity of the SSAO (Screen Space Ambient Occlusion) for the scene. The intensity value affects brightness of shadows:
- By the minimum value of 0.0f, the ambient occlusion shadowing is the lightest.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSAO intensity value. The default value is 1.0f.void engine.render.setSSAOIntensityLightedSide ( float side ) #
Console: render_ssao_intensity_lighted_side
Sets the intensity of the SSAO (Screen Space Ambient Occlusion) for the scene object's lighted side.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float side - SSAO intensity value for the scene object's lighted side. The default value is 1.0f.
float engine.render.getSSAOIntensityLightedSide ( ) #
Console: render_ssao_intensity_lighted_side
Returns the intensity of SSAO(Screen Space Ambient Occlusion) for the scene objects' lighted side.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSAO intensity value for the scene object's lighted side. The default value is 1.0f.void engine.render.setSSAOIntensityReflection ( float reflection ) #
Console: render_ssao_intensity_reflection
Sets the intensity of SSAO (Screen Space Ambient Occlusion) on reflections.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float reflection - SSAO intensity value for reflections. The default value is 1.0f.
float engine.render.getSSAOIntensityReflection ( ) #
Console: render_ssao_intensity_reflection
Returns the intensity of SSAO (Screen Space Ambient Occlusion) on reflections.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSAO intensity value for reflections. The default value is 1.0f.void engine.render.setSSAONoise ( int noise ) #
Console: render_ssao_noise
Enables or disables noise for the SSAO (Screen Space Ambient Occlusion) effect. This option reduces banding effect.
Notice
It is recommended to use noise with TAA enabled.
Arguments
- int noise - 1 to enable SSAO noise, 0 to disable. The default value is 1.
int engine.render.isSSAONoise ( ) #
Console: render_ssao_noise
Returns the value indicating if noise for the SSAO (Screen Space Ambient Occlusion) effect is enabled. This option reduces banding effect.
Notice
It is recommended to use noise with TAA enabled.
Return value
1 if SSAO noise is enabled; otherwise, 0.void engine.render.setSSAOQuality ( int quality ) #
Console: render_ssao_quality
Sets the quality of SSAO(Screen Space Ambient Occlusion).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - Quality of SSAO:
- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
int engine.render.getSSAOQuality ( ) #
Console: render_ssao_quality
Returns the quality of SSAO (Screen Space Ambient Occlusion).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Quality of SSAO:- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
void engine.render.setSSAORadius ( float radius ) #
Console: render_ssao_radius
Sets the radius of SSAO (Screen Space Ambient Occlusion).The radius is the distance for each of the points in the world space, up to which they can shadow their neighboring points:
- By low values, each point can cast shadows only on the points in the close range.
- By high values, each point casts shadows on points at more distant locations.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float radius - SSAO radius value. The default value is 1.0f.
float engine.render.getSSAORadius ( ) #
Console: render_ssao_radius
Returns the radius of SSAO (Screen Space Ambient Occlusion).The radius is the distance for each of the points in the world space, up to which they can shadow their neighboring points:
- By low values, each point can cast shadows only on the points in the close range.
- By high values, each point casts shadows on points at more distant locations.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSAO radius value.void engine.render.setSSAOThreshold ( float threshold ) #
Console: render_ssao_threshold
Sets the threshold value for the SSAO (Screen Space Ambient Occlusion) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - SSAO threshold value in the range [0.0f; 1.0f]. The default value is 0.5f.
float engine.render.getSSAOThreshold ( ) #
Console: render_ssao_threshold
Returns the current threshold value for the SSAO (Screen Space Ambient Occlusion) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current SSAO threshold value.void engine.render.setSSAORayTracing ( int tracing ) #
Console: render_ssao_ray_tracing
Enables or disables ray tracing for SSAO (Screen Space Ambient Occlusion) calculation. When enabled, SSAO provides more realistic shadows between the objects.
Notice
Ray-traced SSAO calculation available only when the SSRTGI technique is enabled.
Arguments
- int tracing - 1 to enable ray tracing for SSAO calculation, 0 to disable. The default value is 1.
int engine.render.isSSAORayTracing ( ) #
Console: render_ssao_ray_tracing
Returns a value indicating if ray tracing is used for SSAO (Screen Space Ambient Occlusion) calculation. When enabled, SSAO provides more realistic shadows between the objects.
Notice
Ray-traced SSAO calculation available only when the SSRTGI technique is enabled.
Return value
1 if ray tracing is used for SSAO calculation; otherwise, 0.void engine.render.setSSAORayTracingDenoise ( int denoise ) #
Console: render_ssao_ray_tracing_denoise
Enables or disables noise reduction for the ray-traced SSAO (Screen Space Ambient Occlusion). This option reduces noise by using blur effect.
Notice
Ray-traced SSAO calculation available only when the SSRTGI technique is enabled.
Arguments
- int denoise - 1 to enable noise reduction for the ray-traced SSAO, 0 to disable.
int engine.render.isSSAORayTracingDenoise ( ) #
Console: render_ssao_ray_tracing_denoise
Returns the value indicating if noise reduction for the ray-traced SSAO (Screen Space Ambient Occlusion) is enabled. This option reduces noise by using blur effect.
Notice
Ray-traced SSAO calculation available only when the SSRTGI technique is enabled.
Return value
1 if noise reduction for the ray-traced SSAO is enabled; otherwise, 0.void engine.render.setSSAORayTracingThreshold ( float threshold ) #
Console: render_ssao_ray_tracing_threshold
Sets the threshold value for the ray-traced SSAO (Screen Space Ambient Occlusion).
Notice
Ray-traced SSAO calculation available only when the SSRTGI technique is enabled.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - SSAO ray tracing threshold value. The default value is 1.0f.
float engine.render.getSSAORayTracingThreshold ( ) #
Console: render_ssao_ray_tracing_threshold
Returns the current threshold value for the ray-traced SSAO (Screen Space Ambient Occlusion).
Notice
Ray-traced SSAO calculation available only when the SSRTGI technique is enabled.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSAO ray tracing threshold value. The default value is 1.0f.void engine.render.setSSAOResolution ( int resolution ) #
Console: render_ssao_resolution
Sets the resolution of SSAO (Screen Space Ambient Occlusion).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int resolution - Resolution of SSAO:
- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
int engine.render.getSSAOResolution ( ) #
Console: render_ssao_resolution
Returns the resolution of SSAO (Screen Space Ambient Occlusion).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Resolution of SSAO:- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
void engine.render.setSSGI ( int ssgi ) #
Console: render_ssgi
Enables or disables the SSGI (Screen Space Global Illumination) effect.Arguments
- int ssgi - 1 to enable the SSGI effect, 0 to disable it. The default value is 0.
int engine.render.isSSGI ( ) #
Console: render_ssgi
Returns the value indicating if the SSGI (Screen Space Global Illumination) effect is enabled.Return value
1 if the SSGI effect is enabled; otherwise, 0.void engine.render.setSSGIIntensity ( float intensity ) #
Console: render_ssgi_intensity
Sets the intensity of the SSGI (Screen Space Global Illumination) for the scene.
- By the minimum value of 0.0f, the global illumination is the darkest.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - SSGI intensity value. The default value is 1.0f.
float engine.render.getSSGIIntensity ( ) #
Console: render_ssgi_intensity
Returns the intensity of the SSGI (Screen Space Global Illumination) for the scene.
- By the minimum value of 0.0f, the global illumination is the darkest.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSGI intensity value. The default value is 1.0f.void engine.render.setSSGIRadius ( float radius ) #
Console: render_ssgi_radius
Sets the radius of the SSGI (Screen Space Global Illumination). The radius determines the size of the region surrounding a particular sampling point:
- By low values, each point affects only the points in the close range.
- By high values, each point affects farther positioned points.
Arguments
- float radius - SSGI radius value. The default value is 1.0f.
float engine.render.getSSGIRadius ( ) #
Console: render_ssgi_radius
Returns the radius of the SSGI (Screen Space Global Illumination). The radius determines the size of the region surrounding a particular sampling point:
- By low values, each point affects only the points in the close range.
- By high values, each point affects farther positioned points.
Return value
SSGI radius value. The default value is 1.0f.void engine.render.setSSGIDenoise ( int denoise ) #
Console: render_ssgi_denoise
Enables or disables noise reduction for the ray-traced SSGI (Screen Space Global Illumination). This option reduces noise by using blur effect.
Notice
Ray-traced SSGI calculation available only when the SSRTGI technique is enabled.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int denoise - 1 to enable noise reduction for the ray-traced SSGI, 0 to disable.
int engine.render.isSSGIDenoise ( ) #
Console: render_ssgi_denoise
Returns a value indicating if noise reduction for the ray-traced SSGI (Screen Space Global Illumination) is enabled. This option reduces noise by using blur effect.
Notice
Ray-traced SSGI calculation available only when the SSRTGI technique is enabled.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if noise reduction for the ray-traced SSGI is enabled; otherwise, 0.void engine.render.setSSGIThreshold ( float threshold ) #
Console: render_ssgi_threshold
Sets the threshold value for the ray-traced SSGI (Screen Space Global Illumination).
Notice
Ray-traced SSGI calculation available only when the SSRTGI technique is enabled.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - SSGI ray tracing threshold value. The default value is 1.0f.
float engine.render.getSSGIThreshold ( ) #
Console: render_ssgi_threshold
Returns the current threshold value for the ray-traced SSGI (Screen Space Global Illumination).
Notice
Ray-traced SSGI calculation available only when the SSRTGI technique is enabled.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSGI ray tracing threshold value. The default value is 1.0f.void engine.render.setSSGIResolutionColor ( int color ) #
Console: render_ssgi_resolution_color
Sets the resolution of the color buffer used for SSGI (Screen Space Global Illumination) calculation. This option significantly affects performance.Arguments
- int color - One of the following values:
- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
int engine.render.getSSGIResolutionColor ( ) #
Console: render_ssgi_resolution_color
Returns the resolution of the color buffer used for SSGI (Screen Space Global Illumination) calculation.Return value
One of the following values:- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
void engine.render.setSSR ( int ssr ) #
Console: render_ssr
Enables or disables the SSR (Screen Space Reflections) effect.Arguments
- int ssr - 1 to enable the SSR effect, 0 to disable it.
int engine.render.isSSR ( ) #
Console: render_ssr
Returns the value indicating if the SSR (Screen Space Reflections) effect is enabled.Return value
1 if the SSR effect is enabled; otherwise, 0. The default value is 1.void engine.render.setSSRDenoise ( int denoise ) #
Console: render_ssr_denoise
Enables or disables noise reduction for the SSR (Screen Space Reflections) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int denoise - 1 to enable noise reduction for the SSR effect, 0 to disable it.
int engine.render.isSSRDenoise ( ) #
Console: render_ssr_denoise
Returns the value indicating if noise reduction for the SSR (Screen Space Reflections) effect is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if noise reduction for the SSR effect is enabled; otherwise, 0.void engine.render.setSSRFastTracing ( int tracing ) #
Console: render_ssr_fast_tracing
Enables or disables fast tracing for the SSR (Screen Space Reflections) effect. This mode makes it possible to obtain distant reflections using low number of steps while keeping performance high. However, tiny objects may not be reflected. Disabling this mode improves quality but significantly drops performance.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int tracing - 1 to enable SSR fast tracing, 0 to disable it. The default value is 1.
int engine.render.isSSRFastTracing ( ) #
Console: render_ssr_fast_tracing
Returns the value indicating if fast tracing for the SSR (Screen Space Reflections) effect is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if SSR fast tracing is enabled; otherwise, 0.void engine.render.setSSRIncreasedAccuracy ( int accuracy ) #
Console: render_ssr_increased_accuracy
Enables or disables increased accuracy for the SSR (Screen Space Reflections). This option reduces visual artifacts around objects, which can appear at resolution lower than full, by increasing accuracy of the last step.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int accuracy - 1 to enable increased accuracy for the SSR, 0 to disable it. The default value is 0.
int engine.render.isSSRIncreasedAccuracy ( ) #
Console: render_ssr_increased_accuracy
Returns a value indicating if increased accuracy option is enabled for the SSR (Screen Space Reflections). This option reduces visual artifacts around objects, which can appear at resolution lower than full, by increasing accuracy of the last step.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if increased accuracy is enabled for the SSR; otherwise, 0.void engine.render.setSSRNoiseRay ( float ray ) #
Console: render_ssr_noise_ray
Sets the intensity of the ray noise used for SSR (Screen Space Reflections) calculation. This parameter is used to reduce the banding effect on rough reflections by using the noise.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float ray - Ray noise intensity in range [0.0f;1.0f]. The default value is 0.5f. The higher is the value, the less pronounced is the banding effect.
float engine.render.getSSRNoiseRay ( ) #
Console: render_ssr_noise_ray
Returns the intensity of the ray noise used for SSR (Screen Space Reflections) calculation. This parameter is used to reduce the banding effect on rough reflections by using the noise.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Ray noise intensity.void engine.render.setSSRNoiseStep ( float step ) #
Console: render_ssr_noise_step
Sets the intensity of the step noise used for SSR (Screen Space Reflections) calculation. This parameter is used to reduce the banding effect of tracing by using the noise.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float step - Step noise intensity. The default value is 0.3f. The higher is the value, the less pronounced is the banding effect.
float engine.render.getSSRNoiseStep ( ) #
Console: render_ssr_noise_step
Returns the intensity of the step noise used for SSR (Screen Space Reflections) calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Step noise intensity.void engine.render.setSSRNumRays ( int rays ) #
Console: render_ssr_num_rays
Sets the number of rays of SSR (Screen Space Reflections) per pixel that are used to calculate rough refrections. Using more rays provides more precise SSR roughness calculation, however, it is more expensive.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int rays - Number of rays per pixel within the [1; 64] range. The default value is 4.
int engine.render.getSSRNumRays ( ) #
Console: render_ssr_num_rays
Returns the number of rays of SSR (Screen Space Reflections) per pixel that are used to calculate rough refrections.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Number of rays per pixel within the [1; 64] range.void engine.render.setSSRNumSteps ( int steps ) #
Console: render_ssr_num_steps
Sets the number of steps of SSR (Screen Space Reflections) per ray that are used for trace calculation. Defines accuracy of reflections and causes a reasonable performance impact. The higher the value, the more accurate obstacles between objects are accounted.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int steps - Number of steps per ray within the [1; 64] range. The default value is 16.
int engine.render.getSSRNumSteps ( ) #
Console: render_ssr_num_steps
Returns the number of steps of SSR (Screen Space Reflections) per ray that are used for trace calculation. The number of steps defines accuracy of reflections and causes a reasonable performance impact. The higher the value, the more accurate obstacles between objects are accounted.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Number of steps per ray within the [1; 64] range.void engine.render.setSSRResolution ( int resolution ) #
Console: render_ssr_resolution
Sets the resolution of SSR (Screen Space Reflections).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int resolution - SSR resolution:
- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
int engine.render.getSSRResolution ( ) #
Console: render_ssr_resolution
Returns the resolution of SSR (Screen Space Reflections).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
One of the following values:- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
void engine.render.setSSRResolutionColor ( int color ) #
Console: render_ssr_resolution_color
Sets the resolution of the color buffer used for SSR (Screen Space Reflections) calculation. This option significantly affects performance.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int color - Color buffer resolution:
- 0 - quarter resolution (by default).
- 1 - half resolution.
- 2 - full resolution.
int engine.render.getSSRResolutionColor ( ) #
Console: render_ssr_resolution_color
Returns the resolution of the color buffer used for SSR (Screen Space Reflections) calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Color buffer resolution:- 0 - quarter resolution (by default).
- 1 - half resolution.
- 2 - full resolution.
void engine.render.setSSRResolutionDepth ( int depth ) #
Console: render_ssr_resolution_depth
Sets the resolution of the depth buffer used for SSR (Screen Space Reflections) calculation. This option affects detailing of reflections of tiny objects.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int depth - Depth buffer resolution:
- 0 - quarter resolution (by default).
- 1 - half resolution.
- 2 - full resolution.
NoticeTo gain performance, this option can be set to lower values while enabling increased accuracy.
int engine.render.getSSRResolutionDepth ( ) #
Console: render_ssr_resolution_depth
Returns the resolution of the depth buffer used for SSR (Screen Space Reflections) calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Depth buffer resolution:- 0 - quarter resolution (by default).
- 1 - half resolution.
- 2 - full resolution.
void engine.render.setSSRStepSize ( float size ) #
Console: render_ssr_step_size
Sets the size of the trace step used for SSR (Screen Space Reflections) calculation. The higher the value, the longer the trace. However, tiny objects may be missed. The lower the value, the more detailed will be reflections of the tiny objects.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float size - Step size. The default value is 1.0f.
float engine.render.getSSRStepSize ( ) #
Console: render_ssr_step_size
Returns the size of the trace step used for SSR (Screen Space Reflections) calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Step size.void engine.render.setSSRTGI ( int ssrtgi ) #
Console: render_ssrtgi
Enables or disables the SSRTGI (Screen Space Ray-Traced Global Illumination) effect.Arguments
- int ssrtgi - 1 to enable the SSRTGI effect, 0 to disable. The default value is 1.
int engine.render.isSSRTGI ( ) #
Console: render_ssrtgi
Returns a value indicating if the SSRTGI (Screen Space Ray-Traced Global Illumination) effect is enabled.Return value
1 if the SSRTGI effect is enabled; otherwise, 0.void engine.render.setSSRTGIFastTracing ( int tracing ) #
Console: render_ssrtgi_fast_tracing
Enables or disables fast tracing for the SSRTGI (Screen Space Ray-Traced Global Illumination). This option dynamically changes step size to obtain indirect illumination bounces using low number of steps while keeping performance high. Disabling this option improves quality, but significantly reduces performance. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int tracing - 1 to enable fast tracing for the SSRTGI, 0 to disable. The default value is 1.
int engine.render.isSSRTGIFastTracing ( ) #
Console: render_ssrtgi_fast_tracing
Returns a value indicating if fast tracing is enabled for the SSRTGI (Screen Space Ray-Traced Global Illumination).Return value
1 if the SSRTGI fast tracing is enabled; otherwise, 0.void engine.render.setSSRTGIIncreasedAccuracy ( int accuracy ) #
Console: render_ssrtgi_increased_accuracy
Enables or disables increased accuracy for the SSRTGI (Screen Space Ray-Traced Global Illumination). This option reduces visual artifacts by increasing accuracy of the last step. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int accuracy - 1 to enable increased accuracy for the SSRTGI, 0 to disable. The default value is 1.
int engine.render.isSSRTGIIncreasedAccuracy ( ) #
Console: render_ssrtgi_increased_accuracy
Returns a value indicating if increased accuracy option is enabled for the SSRTGI (Screen Space Ray-Traced Global Illumination).Return value
1 if increased accuracy is enabled for the SSRTGI; otherwise, 0.void engine.render.setSSRTGINoiseRay ( float ray ) #
Console: render_ssrtgi_noise_ray
Sets the intensity of the ray noise used for SSRTGI calculation. This parameter is used to reduce the banding effect on the final image by using the noise: the higher is the value, the less pronounced is the banding effect. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float ray - Ray noise intensity in range [0.0f;1.0f]. The default value is 0.5f. The higher is the value, the less pronounced is the banding effect.
float engine.render.getSSRTGINoiseRay ( ) #
Console: render_ssrtgi_noise_ray
Returns the intensity of the ray noise used for SSRTGI calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Ray noise intensity in range [0.0f;1.0f].void engine.render.setSSRTGINoiseStep ( float step ) #
Console: render_ssrtgi_noise_step
Sets the intensity of the step noise used for SSRTGI calculation. This parameter is used to reduce the banding effect of tracing by using the noise: the higher is the value, the less pronounced is the banding effect. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float step - Step noise intensity in range [0.0f;1.0f]. The default value is 0.5f. The higher is the value, the less pronounced is the banding effect.
float engine.render.getSSRTGINoiseStep ( ) #
Console: render_ssrtgi_noise_step
Returns the intensity of the step noise used for SSRTGI calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Step noise intensity in range [0.0f;1.0f].void engine.render.setSSRTGINumRays ( int rays ) #
Console: render_ssrtgi_num_rays
Sets the number of rays of SSRTGI per pixel that are to calculate the final image. Using more rays provides more precise SSRTGI calculation, however, it is more expensive. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int rays - Number of rays per pixel in range [1;1024]. The default value is 8.
int engine.render.getSSRTGINumRays ( ) #
Console: render_ssrtgi_num_rays
Returns the number of rays of SSRTGI per pixel that are to calculate the final image in range [1;1024].Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Number of rays.void engine.render.setSSRTGINumSteps ( int steps ) #
Console: render_ssrtgi_num_steps
Sets the number of steps of SSRTGI per ray that are used for trace calculation. The higher the value, the more accurate obstacles between objects are accounted. However, this option significantly affects performance. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int steps - Number of steps in range [1;256]. The default value is 8.
int engine.render.getSSRTGINumSteps ( ) #
Console: render_ssrtgi_num_steps
Returns the number of steps of SSRTGI per ray that are used for trace calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Number of steps in range [1;256].void engine.render.setSSRTGIResolution ( int resolution ) #
Console: render_ssrtgi_resolution
Sets the resolution of SSRTGI (Screen Space Ray-Traced Global Illumination). This option significantly affects performance. The SSRTGI effect must be enabled (see the setSSRTGI() method).Arguments
- int resolution - SSRTGI resolution:
- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
int engine.render.getSSRTGIResolution ( ) #
Console: render_ssrtgi_resolution
Returns the resolution of SSRTGI (Screen Space Ray-Traced Global Illumination).Return value
SSRTGI resolution:- 0 - quarter resolution.
- 1 - half resolution (by default).
- 2 - full resolution.
void engine.render.setSSRTGIResolutionDepth ( int depth ) #
Console: render_ssrtgi_resolution_depth
Sets the resolution of the depth buffer used for SSRTGI (Screen Space Ray-Traced Global Illumination) calculation. This option significantly affects performance. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int depth - Depth buffer resolution:
- 0 - quarter resolution (by default).
- 1 - half resolution.
- 2 - full resolution.
NoticeTo gain performance this option can be set to lower values while enabling the increased accuracy.
int engine.render.getSSRTGIResolutionDepth ( ) #
Console: render_ssrtgi_resolution_depth
Returns the resolution of the depth buffer used for SSRTGI (Screen Space Ray-Traced Global Illumination) calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Depth buffer resolution:- 0 - quarter resolution (by default).
- 1 - half resolution.
- 2 - full resolution.
void engine.render.setSSRTGIStepSize ( float size ) #
Console: render_ssrtgi_step_size
Sets the size of the trace step used for SSRTGI calculation. The higher the value, the longer the trace. However, tiny objects may be missed. The lower the value, the more detailed will be the tiny objects. The SSRTGI effect must be enabled (see the setSSRTGI() method).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float size - Step size. The default value is 1.0f.
float engine.render.getSSRTGIStepSize ( ) #
Console: render_ssrtgi_step_size
Returns the size of the trace step used for SSRTGI calculation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Step size.void engine.render.setSSRTGIUpscaling ( int upscaling ) #
Console: render_ssrtgi_upscaling
Enables or disables upscaling for the SSRTGI (Screen Space Ray-Traced Global Illumination). This option makes the quality of edges in half and quarter resolution look closer to full. The SSRTGI effect must be enabled (see the setSSRTGI() method).Arguments
- int upscaling - 1 to enable upscaling for the SSRTGI, 0 to disable it. The default value is 1.
int engine.render.isSSRTGIUpscaling ( ) #
Console: render_ssrtgi_upscaling
Returns a value indicating if the upscaling option is enabled for the SSRTGI (Screen Space Ray-Traced Global Illumination).Return value
1 if the SSRTGI upscaling is enabled; otherwise, 0.void engine.render.setSSRThreshold ( float threshold ) #
Console: render_ssr_threshold
Sets the threshold used for SSR (Screen Space Reflections) calculation. The threshold limits imitation of reflections in areas where SSR cannot get information. The higher the value, the less this effect is.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - SSR threshold value. The default value is 1.0f
float engine.render.getSSRThreshold ( ) #
Console: render_ssr_threshold
Returns the threshold used for SSR (Screen Space Reflections) calculation. The threshold limits imitation of reflections in areas where SSR cannot get information. The higher the value, the less this effect is.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSR threshold.void engine.render.setSSRThresholdOcclusion ( float occlusion ) #
Console: render_ssr_threshold_occlusion
Sets the occlusion threshold value. The occlusion threshold limits imitation of environment cubemap occlusion in areas where SSR cannot get information. The higher the value, the less this effect is. This parameter is mainly used for indoor environment to correct false reflections on occluded areas (false reflections are replaced with black color). For outdoor environment higher values of this parameter are recommended.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float occlusion - SSR threshold occlusion. The default value is 1.0f
float engine.render.getSSRThresholdOcclusion ( ) #
Console: render_ssr_threshold_occlusion
Returns the current occlusion threshold value. The occlusion threshold limits imitation of environment cubemap occlusion in areas where SSR cannot get information. The higher the value, the less this effect is. This parameter is mainly used for indoor environment to correct false reflections on occluded areas (false reflections are replaced with black color). For outdoor environment higher values of this parameter are recommended.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSR threshold occlusion.void engine.render.setSSRVisibilityRoughnessMax ( float val ) #
Console: render_ssr_visibility_roughness_max
Sets the maximum roughness value, starting from which the SSR (Screen Space Reflections) effect is not rendered.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float val - Maximum roughness value within the [0.0f; 1.0f] range. The default value is 1.0f.
float engine.render.getSSRVisibilityRoughnessMax ( ) #
Console: render_ssr_visibility_roughness_max
Returns the maximum roughness value, starting from which the SSR (Screen Space Reflections) effect is not rendered.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Maximum roughness value within the [0.0f; 1.0f] range.void engine.render.setSSRVisibilityRoughnessMin ( float val ) #
Console: render_ssr_visibility_roughness_min
Sets the minimum roughness value, starting from which the SSR (Screen Space Reflections) effect begins to fade out.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float val - Minimum roughness value within the [0.0f; 1.0f] range. The default value is 1.0f.
float engine.render.getSSRVisibilityRoughnessMin ( ) #
Console: render_ssr_visibility_roughness_min
Returns the minimum roughness value, starting from which the SSR (Screen Space Reflections) effect begins to fade out.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Minimum roughness value within the [0.0f; 1.0f] range.void engine.render.setSSSSS ( int sssss ) #
Console: render_sssss
Enables or disables the SSSSS (screen-space subsurface scattering) effect.Arguments
- int sssss - 1 to enable the SSSSS effect, 0 to disable. The default value is 0.
int engine.render.isSSSSS ( ) #
Console: render_sssss
Returns a value indicating if the SSSSS (screen-space subsurface scattering) effect is enabled.Return value
1 if the SSS effect is enabled; otherwise, 0.void engine.render.setSSSSSColor ( vec4 color ) #
Console: render_sssss_color
Sets a subsurface scattering color used to simulate the subsurface component of skin lighting, i.e. the light that bounces inside of the subsurface tissue layers (epidermis and dermis) before exiting. For skin, subsurface color is reddish, due to blood circulating in skin tissues.Arguments
- vec4 color - Subsurface scattering color.
vec4 engine.render.getSSSSSColor ( ) #
Console: render_sssss_color
Returns the current subsurface scattering color.Return value
Subsurface scattering color.void engine.render.setSSSSSQuality ( int quality ) #
Console: render_sssss_quality
Sets the quality of the SSSSS (screen-space subsurface scattering) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - SSS quality:
- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
int engine.render.getSSSSSQuality ( ) #
Console: render_sssss_quality
Returns the quality of the SSSSS (screen-space subsurface scattering) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSS quality:- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
void engine.render.setSSSSSRadius ( float radius ) #
Console: render_sssss_radius
Sets the subsurface scattering radius: distance in the screen space, within which colors will be sampled. It controls how much wrinkles, pores and cavities will be blurred and highlighted. The higher the value, the farther subsurface scattering reaches. Too high values result in the ghosting effect. By the minimum value of 0, no subsurface scattering is rendered.Arguments
- float radius - Subsurface scattering radius. The default value is 1.0f.
float engine.render.getSSSSSRadius ( ) #
Console: render_sssss_radius
Returns the current subsurface scattering radius.Return value
Subsurface scattering radius value.void engine.render.setSSSSSResolution ( int resolution ) #
Console: render_sssss_resolution
Sets the resolution of the SSSSS (screen-space subsurface scattering) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int resolution - SSS resolution:
- 0 - half resolution (by default).
- 1 - full resolution.
int engine.render.getSSSSSResolution ( ) #
Console: render_sssss_resolution
Returns the resolution of the SSSSS (screen-space subsurface scattering) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
SSS resolution:- 0 - half resolution (by default).
- 1 - full resolution.
void engine.render.setViewportMode ( int mode ) #
Console: render_viewport_mode
Sets a new viewport rendering mode (default, stereo, or panoramic).Arguments
- int mode - New viewport mode to be set. One of the VIEWPORT_MODE_* values.
int engine.render.getViewportMode ( ) #
Console: render_viewport_mode
Returns the current viewport rendering mode (default, stereo, or panoramic).Return value
Current viewport mode. One of the VIEWPORT_MODE_* values.int engine.render.isViewportModeStereo ( int mode ) #
Returns a value indicating if the specified mode is one of the stereo rendering modes.Arguments
- int mode - Viewport mode to be checked. One of the VIEWPORT_MODE_* values.
Return value
1 if the specified mode is one of the stereo rendering modes; otherwise 0.int engine.render.isViewportModePanorama ( int mode ) #
Returns a value indicating if the specified mode is one of the panorama rendering modes.Arguments
- int mode - Viewport mode to be checked. One of the VIEWPORT_MODE_* values.
Return value
1 if the specified mode is one of the panorama rendering modes; otherwise 0.void engine.render.setStereoDistance ( float distance ) #
Sets the focal distance for stereo rendering (distance in the world space to the point where two views line up, i.e. to the zero parallax plane).Arguments
- float distance - Focal distance for stereo rendering, in units.
float engine.render.getStereoDistance ( ) #
Returns the focal distance for stereo rendering (distance in the world space to the point where two views line up).Return value
Focal distance for stereo rendering, in units.void engine.render.setStereoOffset ( float offset ) #
Sets the virtual camera offset (an offset after the perspective projection).Arguments
- float offset - Virtual camera offset in units.
float engine.render.getStereoOffset ( ) #
Returns the virtual camera offset (an offset after the perspective projection).Return value
Virtual camera offset in units.void engine.render.setStereoRadius ( float radius ) #
Sets the radius for stereo (the half of the separation distance between the cameras).Arguments
- float radius - Stereo radius, in units. If a negative value is provided, 0 will be used instead.
float engine.render.getStereoRadius ( ) #
Returns the current radius for stereo (the half of the separation distance between the cameras).Return value
Stereo radius, in units.void engine.render.setSupersampling ( float supersampling ) #
Console: render_supersampling
Sets the number of samples per pixel used for supersampling.Arguments
- float supersampling - Number of samples per pixel within the range [1e-6f; 8.0f]. The default value is 1.0f
float engine.render.getSupersampling ( ) #
Console: render_supersampling
Returns the number of samples per pixel used for supersampling.Return value
Number of samples per pixel.void engine.render.setTAAFramesByColor ( int color ) #
Console: render_taa_frames_by_color
Enables or disables the TAA color clamping option. When enabled, the pixel color of the current and the previous frames is clamped. The image becomes more sharp, however, flickering can appear. Clamping is available only when TAA is enabled.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int color - 1 to enable the TAA color clamping option, 0 to disable it. The default value is 1.
int engine.render.isTAAFramesByColor ( ) #
Console: render_taa_frames_by_color
Returns a value indicating if the TAA color clamping option is enabled. When enabled, the pixel color of the current and the previous frames is clamped. Clamping is available only when TAA is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if TAA color clamping is enabled; otherwise, 0.void engine.render.setTAADiagonalNeighbors ( int neighbors ) #
Console: render_taa_diagonal_neighbors
Sets a value indicating if diagonally neighboring pixels are to be taken into account in the process of color clamping for TAA. This mode can be used for relatively static scenes when improved antialiasing is required. In case of a dynamic scene, blurring artefacts near the screen borders may appear.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int neighbors - 1 to take diagonally neighboring pixels into account in the process of color clamping for TAA, 0 to ignore them.
int engine.render.isTAADiagonalNeighbors ( ) #
Console: render_taa_diagonal_neighbors
Returns a value indicating if diagonally neighboring pixels are to be taken into account in the process of color clamping for TAA. This mode can be used for relatively static scenes when improved antialiasing is required. In case of a dynamic scene, blurring artefacts near the screen borders may appear.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if diagonally neighboring pixels are to be taken into account in the process of color clamping for TAA; otherwise, 0.void engine.render.setTAAFixFlicker ( int flicker ) #
Console: render_taa_fix_flicker
Enables or disables the TAA fix flicker option. This option fixes flickering edges caused by TAA: it removes bright pixels by using the pixel brightness information from the previous frame. It is recommended to enable the option for bright thin ropes, wires and lines. The option is available only when TAA is enabled.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int flicker - 1 to enable the TAA fix flicker option, 0 to disable it. The default value is 1.
int engine.render.isTAAFixFlicker ( ) #
Console: render_taa_fix_flicker
Returns a value indicating if the TAA fix flicker option is enabled. This option fixes flickering edges caused by TAA: it removes bright pixels by using the pixel brightness information from the previous frame. It is recommended to enable the option for bright thin ropes, wires and lines. The option is available only when TAA is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the TAA fix flicker option is enabled; otherwise, 0.void engine.render.setTAAFrameCount ( float count ) #
Console: render_taa_frame_count
Sets the frame count of TAA (Temporal Anti-Aliasing). Specifies the number of frames combined for pixels. The higher the value, the more frames are combined into the final image and the better anti-aliasing.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float count - TAA frame count value. The default value is 30.0f.
float engine.render.getTAAFrameCount ( ) #
Console: render_taa_frame_count
Returns the frame count of TAA (Temporal Anti-Aliasing). Specifies the number of frames combined for pixels. The higher the value, the more frames are combined into the final image and the better anti-aliasing.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
TAA frame count value.void engine.render.setTAAMaxFramesByVelocity ( float velocity ) #
Console: render_taa_max_frames_by_velocity
Sets the maximum frame count of TAA (Temporal Anti-Aliasing). Specifies the maximum number of frames combined for pixels that don't move relative to the screen space.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float velocity - Maximum TAA frame count value. The default value is 60.0f.
float engine.render.getTAAMaxFramesByVelocity ( ) #
Console: render_taa_max_frames_by_velocity
Returns the maximum frame count of TAA (Temporal Anti-Aliasing). Specifies the maximum number of frames combined for pixels that don't move relative to the screen space.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Maximum TAA frame count value.void engine.render.setTAAMinFramesByVelocity ( float velocity ) #
Console: render_taa_min_frames_by_velocity
Sets the minimum frame count of TAA (Temporal Anti-Aliasing). Specifies the minimum number of frames combined for fast moving pixels on the screen.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float velocity - Minimum TAA frame count value. The default value is 4.0f.
float engine.render.getTAAMinFramesByVelocity ( ) #
Console: render_taa_min_frames_by_velocity
Returns the minimum frame count of TAA (Temporal Anti-Aliasing). Specifies the minimum number of frames combined for fast moving pixels on the screen.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Minimum TAA frame count value.void engine.render.setTAAPreserveDetails ( float details ) #
Console: render_taa_preserve_details
Sets the detail level of TAA (Temporal Anti-Aliasing). The higher the value, the more detailed the image is. Can produce additional flickering.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float details - TAA detail level value. The default value is 1.5f.
float engine.render.getTAAPreserveDetails ( ) #
Console: render_taa_preserve_details
Returns the detail level of TAA (Temporal Anti-Aliasing). The higher the value, the more detailed the image is. Can produce additional flickering.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
TAA detail level value.void engine.render.setTAAFramesByVelocity ( int velocity ) #
Console: render_taa_frames_by_velocity
Enables or disables the TAA velocity clamping option. This option controls the number of frames combined for pixels depending on the velocity in the fragment: the number of frames is clamped to the [Min frame count;Max frame count]. It reduces blurring in dynamic scenes with a lot of moving objects.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int velocity - 1 to enable the TAA velocity clamping option, 0 to disable it. The default value is 1.
int engine.render.isTAAFramesByVelocity ( ) #
Console: render_taa_frames_by_velocity
Returns a value indicating if the TAA velocity clamping option is enabled. T This option controls the number of frames combined for pixels depending on the velocity in the fragment: the number of frames is clamped to the [Min frame count;Max frame count]. It reduces blurring in dynamic scenes with a lot of moving objects.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if TAA velocity clamping is enabled; otherwise, 0.void engine.render.setTAAFramesVelocityThreshold ( float threshold ) #
Console: render_taa_frames_velocity_threshold
Sets the velocity threshold of TAA (Temporal Anti-Aliasing), at which pixels are treated as fast moving ones.Arguments
- float threshold - TAA velocity threshold value. The default value is 1.0f.
float engine.render.getTAAFramesVelocityThreshold ( ) #
Console: render_taa_frames_velocity_threshold
Returns the velocity threshold of TAA (Temporal Anti-Aliasing), at which pixels are treated as fast moving ones.Return value
TAA velocity threshold value.void engine.render.setTerrainGlobalAnisotropy ( int anisotropy ) #
Console: render_terrain_global_anisotropy
Sets the global terrain texture anisotropy level (degree of anisotropic filtering). Anisotropy for the global terrain has a huge impact for the performance if terrain has a lot of tiled detail materials as anisotropy filtering for the terrain is much slower than for the other objects.Arguments
- int anisotropy - Anisotropy level:
- 0 - anisotropy level 1.
- 1 - anisotropy level 2.
- 2 - anisotropy level 4 (by default).
- 3 - anisotropy level 8.
- 4 - anisotropy level 16.
int engine.render.getTerrainGlobalAnisotropy ( ) #
Console: render_terrain_global_anisotropy
Returns the current global terrain texture anisotropy level (degree of anisotropic filtering). Anisotropy for the global terrain has a big impact for the performance if terrain has a lot of tiled detail materials.Return value
Anisotropy level:- 0 - anisotropy level 1.
- 1 - anisotropy level 2.
- 2 - anisotropy level 4 (by default).
- 3 - anisotropy level 8.
- 4 - anisotropy level 16.
void engine.render.setTerrainGlobalDisplacement ( int displacement ) #
Console: render_terrain_global_displacement
Enables or disables displacement mapping for the global terrain.Arguments
- int displacement - 1 to enable displacement mapping for the global terrain; 0 to disable it. The default value is 1.
int engine.render.isTerrainGlobalDisplacement ( ) #
Console: render_terrain_global_displacement
Returns a value indicating if displacement mapping is enabled for the global terrain.Return value
1 if displacement mapping is enabled for the global terrain; otherwise, 0.void engine.render.setTerrainGlobalDisplacementNormal ( int normal ) #
Enables or disables use of normals in displacement mapping for global terrain rendering.Arguments
- int normal - 1 to enable displacement mapping for the global terrain; 0 to disable it. The default value is 1.
int engine.render.isTerrainGlobalDisplacementNormal ( ) #
Returns a value indicating if displacement mapping for global terrain rendering uses normals.Return value
1 if displacement mapping for global terrain rendering uses normals; otherwise, 0.void engine.render.setTerrainGlobalHoles ( int holes ) #
Console: render_terrain_global_holes
Sets a value indicating if decal-based holes for the global terrain are enabled.Arguments
- int holes - 1 to enable decal-based holes for the global terrain; otherwise, 0.
int engine.render.isTerrainGlobalHoles ( ) #
Console: render_terrain_global_holes
Returns a value indicating if decal-based holes for the global terrain are enabled.Return value
1 if decal-based holes for the global terrain are enabled; otherwise, 0.void engine.render.setTerrainGlobalTriplanar ( int triplanar ) #
Console: render_terrain_global_triplanar
Enables or disables triplanar texture mapping for the global terrain.Arguments
- int triplanar - 1 to enable triplanar texture mapping for the global terrain; 0 to use planar UV mapping instead.
int engine.render.isTerrainGlobalTriplanar ( ) #
Console: render_terrain_global_triplanar
Returns a value indicating if triplanar texture mapping is enabled for the global terrain.Return value
1 if triplanar texture mapping is enabled for the global terrain; otherwise, 0.void engine.render.setTexturesAnisotropy ( int anisotropy ) #
Console: render_textures_anisotropy
Sets the anisotropy level for textures (degree of anisotropic filtering).Arguments
- int anisotropy - Anisotropy level:
- 0 - anisotropy level 1.
- 1 - anisotropy level 2.
- 2 - anisotropy level 4.
- 3 - anisotropy level 8 (by default).
- 4 - anisotropy level 16.
int engine.render.getTexturesAnisotropy ( ) #
Console: render_textures_anisotropy
Returns current anisotropy level for textures (degree of anisotropic filtering).Return value
Anisotropy level:- 0 - anisotropy level 1.
- 1 - anisotropy level 2.
- 2 - anisotropy level 4.
- 3 - anisotropy level 8 (by default).
- 4 - anisotropy level 16.
void engine.render.setTexturesFilter ( int filter ) #
Console: render_textures_filter
Sets the texture filtering mode.Arguments
- int filter - Texture filtering mode:
- 0 - bilinear filtering.
- 1 - trilinear filtering (by default).
int engine.render.getTexturesFilter ( ) #
Console: render_textures_filter
Returns the current texture filtering mode.Return value
Texture filtering mode:- 0 - bilinear filtering.
- 1 - trilinear filtering (by default).
void engine.render.setTexturesMaxResolution ( int resolution ) #
Console: render_textures_max_resolution
Sets the maximum resolution of all textures. The engine doesn't compress existing textures: it uses specified mipmaps of *.dds textures.Arguments
- int resolution - Maximum resolution:
- 0 - 128 x 128.
- 1 - 256 x 256.
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192 (by default).
- 7 - 16384 x 16384.
int engine.render.getTexturesMaxResolution ( ) #
Console: render_textures_max_resolution
Returns the current maximum resolution of all textures. The engine doesn't compress existing textures: it uses specified mipmaps of *.dds textures.Return value
Maximum resolution:- 0 - 128 x 128.
- 1 - 256 x 256.
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192 (by default).
- 7 - 16384 x 16384.
void engine.render.setTexturesMinResolution ( int resolution ) #
Console: render_textures_min_resolution
Sets the minimum resolution of all textures. The engine doesn't compress existing textures: it uses specified mip maps of *.dds textures.Arguments
- int resolution - Minimum resolution:
- 0 - 128 x 128 (by default).
- 1 - 256 x 256.
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192.
- 7 - 16384 x 16384.
int engine.render.getTexturesMinResolution ( ) #
Console: render_textures_min_resolution
Returns the current minimum resolution of all textures. The engine doesn't compress existing textures: it uses specified mipmaps of *.dds textures.Return value
Minimum resolution:- 0 - 128 x 128 (by default).
- 1 - 256 x 256.
- 2 - 512 x 512.
- 3 - 1024 x 1024.
- 4 - 2048 x 2048.
- 5 - 4096 x 4096.
- 6 - 8192 x 8192.
- 7 - 16384 x 16384.
void engine.render.setTexturesQuality ( int quality ) #
Console: render_textures_quality
Sets the resolution of textures.Arguments
- int quality - One of the RENDER_QUALITY_* pre-defined variables.
int engine.render.getTexturesQuality ( ) #
Console: render_textures_quality
Returns the current resolution of textures.Return value
One of the RENDER_QUALITY_* pre-defined variables.void engine.render.setTransparentBlur ( int blur ) #
Console: render_transparent_blur
Enables or disables transparent blur for materials. This option makes it possible to render matte transparent materials like matte glass.Arguments
- int blur - 1 to enable transparent blur for materials, 0 to disable it. The default value is 1.
int engine.render.isTransparentBlur ( ) #
Console: render_transparent_blur
Returns a value indicating if transparent blur is enabled for materials. This option makes it possible to render matte transparent materials like matte glass.Return value
1 if transparent blur is enabled for materials; otherwise, 0.void engine.render.setViewport ( Viewport viewport ) #
Sets a viewport for a main application window.Arguments
- Viewport viewport - Viewport instance.
Viewport engine.render.getViewport ( ) #
Returns a main application window viewport.Return value
Viewport instance.void engine.render.setVirtualResolution ( vec2 resolution ) #
Console: render_virtual_resolution
Sets virtual screen resolution. This option can be used to render video with high resolution (e.g. 8K) regardless of monitor's resolution.Arguments
- vec2 resolution - Virtual screen resolution (X, Y), in pixels. The default value is (-1, -1).
vec2 engine.render.getVirtualResolution ( ) #
Console: render_virtual_resolution
Returns the current virtual screen resolution.Return value
Virtual screen resolution (X, Y), in pixels.void engine.render.setVREmulation ( int emulation ) #
Console: render_vr_emulation
Sets the VR-emulation mode.Arguments
- int emulation - VR-emulation mode:
- 0 - disabled (by default).
- 1 - HTC Vive emulation.
- 2 - HTC Vive Pro emulation.
- 3 - Oculus Rift emulation.
int engine.render.getVREmulation ( ) #
Console: render_vr_emulation
Returns the value indicating the current VR-emulation mode.Return value
VR-emulation mode:- 0 - disabled (by default).
- 1 - HTC Vive emulation.
- 2 - HTC Vive Pro emulation.
- 3 - Oculus Rift emulation.
void engine.render.setWaterAnisotropy ( int anisotropy ) #
Console: render_water_anisotropy
Sets water texture anisotropy level.Arguments
- int anisotropy - Anisotropy level:
- 0 - anisotropy level 1.
- 1 - anisotropy level 2 (by default).
- 2 - anisotropy level 4.
- 3 - anisotropy level 8.
- 4 - anisotropy level 16.
int engine.render.getWaterAnisotropy ( ) #
Console: render_water_anisotropy
Returns current water texture anisotropy level.Return value
Anisotropy level:- 0 - anisotropy level 1.
- 1 - anisotropy level 2 (by default).
- 2 - anisotropy level 4.
- 3 - anisotropy level 8.
- 4 - anisotropy level 16.
void engine.render.setWaterEnvironmentProbes ( int probes ) #
Console: render_water_environment_probes
Enables or disables rendering of environment probes on the water surface.Arguments
- int probes - 1 to enable rendering of environment probes on the water surface, 0 to disable it. The default value is 1.
int engine.render.isWaterEnvironmentProbes ( ) #
Console: render_water_environment_probes
Returns a value indicating if rendering of environment probes on the water surface is enabled.Return value
1 if rendering of environment probes on the water surface is enabled; otherwise, 0.void engine.render.setWaterVoxelProbes ( int probes ) #
Console: render_water_voxel_probes
Enables or disables voxel probes for water rendering.Arguments
- int probes - 1 to enable voxel probes for water rendering, 0 to disable it. The default value is 1.
int engine.render.isWaterVoxelProbes ( ) #
Console: render_water_voxel_probes
Returns a value indicating if voxel probes are enabled for water rendering.Return value
1 if voxel probes are enabled for water rendering; otherwise, 0.void engine.render.setWaterLights ( int lights ) #
Console: render_water_lights
Enables or disables rendering of lights on the water surface.Arguments
- int lights - 1 to enable rendering of lights on the water surface, 0 to disable it. The default value is 1.
int engine.render.isWaterLights ( ) #
Console: render_water_lights
Returns a value indicating if rendering of lights on the water surface is enabled.Return value
1 if rendering of lights on the water surface is enabled; otherwise, 0.void engine.render.setWaterOpacityDepth ( int depth ) #
Console: render_water_opacity_depth
Enables or disables writing depth data for water to the opacity buffer.Arguments
- int depth - 1 to enable writing depth data for water to the opacity buffer, 0 to disable it. The default value is 1.
int engine.render.isWaterOpacityDepth ( ) #
Console: render_water_opacity_depth
Returns a value indicating if depth data for water is written to the opacity buffer.Return value
1 if depth data for water is written to the opacity buffer; otherwise, 0.void engine.render.setWaterRefractionQuality ( int quality ) #
Console: render_water_refraction_quality
Sets the quality of water refraction.Arguments
- int quality - Refraction quality:
- 0 - low quality.
- 1 - medium quality.
- 2 - high quality (by default).
- 3 - ultra quality.
int engine.render.getWaterRefractionQuality ( ) #
Console: render_water_refraction_quality
Returns current quality of water refraction.Return value
Refraction quality:- 0 - low quality.
- 1 - medium quality.
- 2 - high quality (by default).
- 3 - ultra quality.
void engine.render.setWaterShafts ( int shafts ) #
Console: render_water_shafts
Enables or disables rendering of underwater shafts.Arguments
- int shafts - 1 to enable rendering of underwater shafts, 0 to disable it. The default value is 1.
int engine.render.isWaterShafts ( ) #
Console: render_water_shafts
Returns a value indicating if rendering of underwater shafts is enabled.Return value
1 if rendering of underwater shafts is enabled; otherwise, 0.void engine.render.setWaterShorelineWetness ( int wetness ) #
Console: render_water_shoreline_wetness
Enables or disables the wetness effect for objects near the shoreline.Arguments
- int wetness - 1 to enable shoreline wetness, 0 to disable it. The default value is 1.
int engine.render.isWaterShorelineWetness ( ) #
Console: render_water_shoreline_wetness
Returns a value indicating if the wetness effect for objects near the shoreline is enabled.Return value
1 if shoreline wetness is enabled; otherwise, 0.void engine.render.setWaterSSR ( int waterssr ) #
Console: render_water_ssr
Enables or disables the SSR (Screen Space Reflections) effect for water.Arguments
- int waterssr - 1 to enable the SSR effect for water, 0 to disable.
int engine.render.isWaterSSR ( ) #
Console: render_water_ssr
Returns the value indicating if the SSR (Screen Space Reflections) effect is enabled for water.Return value
1 if the SSR effect is enabled for water; otherwise, 0.void engine.render.setWaterSSRIncreasedAccuracy ( int accuracy ) #
Console: render_water_ssr_increased_accuracy
Enables or disables increased accuracy for the water SSR (Screen Space Reflections). This option reduces visual artifacts by increasing accuracy of the last step.Arguments
- int accuracy - 1 to enable increased accuracy for the water SSR, 0 to disable. The default value is 0.
int engine.render.isWaterSSRIncreasedAccuracy ( ) #
Console: render_water_ssr_increased_accuracy
Returns a value indicating if increased accuracy option is enabled for the water SSR (Screen Space Reflections).Return value
1 if increased accuracy is enabled for the water SSR; otherwise, 0.void engine.render.setWaterSSRQuality ( int quality ) #
Console: render_water_ssr_quality
Sets the resolution of water SSR (Screen Space Reflections).Arguments
- int quality - Water SSR quality:
- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
int engine.render.getWaterSSRQuality ( ) #
Console: render_water_ssr_quality
Returns the resolution of water SSR (Screen Space Reflections).Return value
Water SSR quality:- 0 - low quality.
- 1 - medium quality (by default).
- 2 - high quality.
- 3 - ultra quality.
Texture engine.render.getWhite2DArrayTexture ( ) #
Returns white 2D array texture.Return value
White 2D array texture.Texture engine.render.getWhite2DTexture ( ) #
Returns white 2D texture.Return value
White 2D texture.Texture engine.render.getWhite3DTexture ( ) #
Returns white 3D texture.Return value
White 3D texture.Texture engine.render.getWhiteCubeTexture ( ) #
Returns white Cube texture.Return value
White Cube texture.void engine.render.setWireframeColor ( vec4 color ) #
Console: render_wireframe_color
Sets the color for the wireframe.Arguments
- vec4 color - Wireframe color to be set.
vec4 engine.render.getWireframeColor ( ) #
Console: render_wireframe_color
Returns the color of the wireframe.Return value
Wireframe color.int engine.render.compressImage ( Image & image, int quality = 1, int new_image_format = -1, int use_mip_maps = -1 ) #
Converts the image to a specified compressed format. If compression by the GPU is not supported, the Image::compress() method will be called instead.Arguments
- Image & image - Image to compress.
- int quality - Compression quality:
- 0 - fast compression, low compressed image quality.
- 1 - high compressed image quality, slow compression (by default).
- int new_image_format - Compressed texture format: one of the TEXTURE_FORMAT_* variables. This is an optional argument. If no format is specified, default conversion will be performed (depending on the type of the source image).
- int use_mip_maps - Flag indicating whether texture mipmaps should be generated for the compressed image: 1 to generate mipmaps, 0 not to generate. This is an optional argument. If no value is specified, mipmaps will be generated only if the source image has the mipmaps.
Return value
1 if the image has been compressed successfully; otherwise, 0.int engine.render.compressTexture ( Texture texture, Image & destination, int quality = 1, int new_texture_format = -1, int use_mip_maps = -1 ) #
Compresses the given texture to the specified format.Notice
Only 2d and 2d array textures can be compressed.
Arguments
- Texture texture - Source texture to compress.
- Image & destination - Image into which the compressed texture will be saved.
- int quality - Compression quality:
- 0 - fast compression, low compressed image quality.
- 1 - high compressed image quality, slow compression (by default).
- int new_texture_format - Compressed texture format: one of the TEXTURE_FORMAT_* variables. This is an optional argument. If no format is specified, default conversion will be performed (depending on the type of the source image).
- int use_mip_maps - Flag indicating whether texture mipmaps should be generated for the compressed image: 1 to generate mipmaps, 0 not to generate. This is an optional argument. If no value is specified, mipmaps will be generated only if the source image has the mipmaps.
Return value
1 if the texture has been compressed successfully; otherwise, 0.void engine.render.convertColorSpecularToMetalness ( vec4 & diffuse, vec4 & specular, vec4 & albedo, vec4 & shading ) #
Performs color conversion from the specular workflow (diffuse, specular) to the metalness workflow (albedo, shading).Arguments
- vec4 & diffuse - Input diffuse color.
- vec4 & specular - Input specular color.
- vec4 & albedo - Output albedo color.
- vec4 & shading - Output shading color.
void engine.render.convertImageSpecularToMetalness ( Image diffuse, Image specular, Image & albedo, Image & shading ) #
Performs texture conversion from the specular workflow (diffuse, specular) to the metalness workflow (albedo, shading).Arguments
- Image diffuse - Input diffuse texture.
- Image specular - Input specular texture.
- Image & albedo - Output albedo texture.
- Image & shading - Output shading texture.
int engine.render.createMipmapsCubeGGX ( Image image, float quality ) #
Generates mipmaps for a cubemap using GGX BRDF microfacet model.Arguments
- Image image - Cubemap image. IMAGE_CUBE or IMAGE_CUBE_ARRAY types are accepted.
- float quality - Quality value within the [0.0f; 1.0f] range.
int engine.render.createShorelineDistanceField ( Image image, Image mask, int shoreline_radius, int blur_radius, int downsample_resolution ) #
Grabs a shoreline distance field texture with the specified parameters.Arguments
- Image image - Image to grab a shoreline texture to.
- Image mask - An R16 mask texture Image. Each pixel of the mask has the following color value:0 if water level at this point of the grid is above the terrain level; otherwise, 65535.
- int shoreline_radius - Shoreline radius value within the [4; 128] range. Padding distance (from the shore to the beginning of swash zone).
- int blur_radius - Blur radius value within the [0; 32] range. Higher values make shoreline smoother.
- int downsample_resolution - Texture resolution value, can be one of the following: 16, 32, 64, 128, 256, 512, 1024, 2048.
Return value
1 if the shoreline distance field texture is grabbed successfully; otherwise, 0.int engine.render.loadSettings ( string file, int clear = false ) #
Loads render settings from a given file.Arguments
- string file - Path to an XML file with desired settings.
- int clear - Clear flag. Set 1 to clear settings before loading (new settings shall be applied right after loading them), or 0 not to clear.
Return value
1 if the settings are loaded successfully; otherwise, 0.int engine.render.loadWorld ( Xml xml ) #
Loads render state from the Xml.Arguments
- Xml xml - Xml node.
Return value
1 if the state is loaded successfully; otherwise, 0.void engine.render.renderImage2D ( Camera camera, Image image, int skip_flags ) #
Renders the scene into a 2D image in accordance with the specified parameters. The viewport position is taken from the camera created via Camera class.Arguments
- Camera camera - Camera to be used.
- Image image - Image to save the result to.
- int skip_flags - Skip the effects:
- VIEWPORT_SKIP_SHADOWS
- VIEWPORT_SKIP_VISUALIZER
- VIEWPORT_SKIP_SRGB
- VIEWPORT_SKIP_POSTEFFECTS
- VIEWPORT_SKIP_VELOCITY
- VIEWPORT_SKIP_DYNAMIC_REFLECTIONS
0 enables all the effects.
void engine.render.renderImage2D ( Camera camera, Image image, int width, int height, int hdr, int skip_flags ) #
Renders the scene into a 2D image of the given size in accordance with the specified parameters. The viewport position is taken from the camera created via Camera class.Arguments
- Camera camera - Camera to be used.
- Image image - Image to save the result to.
- int width - Width of the projected image, in units.
- int height - Height of the projected image, in units.
- int hdr - 1 - enable HDR, 0 - disable HDR.
- int skip_flags - Skip the effects:
- VIEWPORT_SKIP_SHADOWS
- VIEWPORT_SKIP_VISUALIZER
- VIEWPORT_SKIP_SRGB
- VIEWPORT_SKIP_POSTEFFECTS
- VIEWPORT_SKIP_VELOCITY
- VIEWPORT_SKIP_DYNAMIC_REFLECTIONS
0 enables all the effects.
void engine.render.renderImageCube ( Camera camera, Image image, int skip_flags ) #
Renders the scene into a cube map image in accordance with the specified parameters.Arguments
- Camera camera - Camera to be used.
- Image image - Image to save the result to.
- int skip_flags - Skip the effects:
- VIEWPORT_SKIP_SHADOWS
- VIEWPORT_SKIP_VISUALIZER
- VIEWPORT_SKIP_SRGB
- VIEWPORT_SKIP_POSTEFFECTS
- VIEWPORT_SKIP_VELOCITY
- VIEWPORT_SKIP_DYNAMIC_REFLECTIONS
0 enables all the effects.
void engine.render.renderImageCube ( Camera camera, Image image, int size, int hdr, int skip_flags, int local_space = 0 ) #
Renders the scene into a cube map in accordance with the specified parameters. The viewport position is taken from the camera created via Camera class.Arguments
- Camera camera - Camera to be used.
- Image image - Image to save the result to.
- int size - Texture dimensions (cube map edge size).
- int hdr - 1 - enable HDR; 0 - disable HDR.
- int skip_flags - Skip the effects:
- VIEWPORT_SKIP_SHADOWS
- VIEWPORT_SKIP_VISUALIZER
- VIEWPORT_SKIP_SRGB
- VIEWPORT_SKIP_POSTEFFECTS
- VIEWPORT_SKIP_VELOCITY
- VIEWPORT_SKIP_DYNAMIC_REFLECTIONS
0 enables all the effects.
- int local_space - 1 - local space coordinates; 0 - world space coordinates.
void engine.render.renderNodeImage2D ( Camera camera, Node node, Image image, int skip_flags, int light_usage, string environment_texture_name ) #
Renders the given node into a 2D image in accordance with the specified parameters. The viewport position is taken from the camera created via Camera class. The node can be rendered using the specific type of lighting and environment cubemap.Arguments
- Camera camera - Camera to be used.
- Node node - Node to be rendered.
- Image image - Image to save the result to.
- int skip_flags - Skip the effects. One of the SKIP_* variables should be specified. 0 enables all the effects.
- int light_usage - Sets the light sources that will affect the node (one of the USAGE_*_LIGHTING Viewport class variables.)
- string environment_texture_name - Path to the environment cubemap to be used. Takes effect if the first (auxiliary light) or second (node light) lighting mode is used (see the light_usage argument above). In case LightWorld is used (zero mode), the environment cubemap used for the current world will be used.
void engine.render.renderNodeImage2D ( Camera camera, Node node, Image image, int width, int height, int hdr, int skip_flags, int light_usage, string environment_texture_name ) #
Renders the 2D image of the given node in accordance with the specified parameters. The viewport position is taken from the camera created via Camera class. The node can be rendered using the specific type of lighting and environment cubemap.Arguments
- Camera camera - Camera to be used.
- Node node - Node to be rendered.
- Image image - Image to save the result to.
- int width - Width of the image, in units.
- int height - Height of the image, in units.
- int hdr - HDR flag. This parameter determines the format of the 2D image:
- 1 - image format will be set to RGBA16F. It means that the HDR image buffer will store pixel values outside the [0;1] range (i.e. both negative and positive values).
- 0 - image format will be set to RGBA8.
- int skip_flags - Skip the effects. One of the SKIP_* variables should be specified. 0 enables all the effects.
- int light_usage - Sets the light sources that will affect the node (one of the USAGE_*_LIGHTING Viewport class variables).
- string environment_texture_name - Path to the environment cubemap to be used. Takes effect if the first (auxiliary light) or second (node light) lighting mode is used (see the light_usage argument above). In case LightWorld is used (zero mode), the environment cubemap used for the current world will be used.
void engine.render.renderScreenMaterial ( string material_name ) #
Arguments
- string material_name - Material name.
void engine.render.renderScreenMaterial ( string material_name, Texture color_texture ) #
Arguments
- string material_name - Material name.
- Texture color_texture - Color texture.
void engine.render.renderScreenMaterial ( string material_name, string texture_name, Texture texture ) #
Arguments
- string material_name - Material.
- string texture_name - Material texture name.
- Texture texture - Texture.
int engine.render.saveSettings ( string file ) #
Saves the current renderer settings to a given file.Arguments
- string file - Path to a target file.
Return value
1 if the settings are saved successfully; otherwise, 0.int engine.render.saveState ( Stream stream ) #
Saves a render state into the stream.Saving into the stream requires creating a blob to save into. To restore the saved state the restoreState() method is used:
Source code (UnigineScript)
// set state
engine.render.setCloudsInterleavedRendering(0); // interleave = 0
// save state
Blob blob_state = new Blob();
engine.render.saveState(blob_state);
// change state
engine.render.setCloudsInterleavedRendering(2); // now interleave = 2
// restore state
blob_state->seekSet(0); // returning the carriage to the start of the blob
engine.render.restoreState(blob_state); // restore interleave = 0Arguments
- Stream stream - Stream to save a state into.
Return value
1 if the state is saved successfully; otherwise, 0.int engine.render.restoreState ( Stream stream ) #
Restores a render state from the stream.Restoring from the stream requires creating a blob to save into and saving the state using the saveState() method:
Source code (UnigineScript)
// set state
engine.render.setCloudsInterleavedRendering(0); // interleave = 0
// save state
Blob blob_state = new Blob();
engine.render.saveState(blob_state);
// change state
engine.render.setCloudsInterleavedRendering(2); // now interleave = 2
// restore state
blob_state->seekSet(0); // returning the carriage to the start of the blob
engine.render.restoreState(blob_state); // restore interleave = 0Arguments
- Stream stream - Stream to restore a state from.
Return value
1 if the state is restored successfully; otherwise, 0.int engine.render.saveWorld ( Xml xml ) #
Saves the render state into the given Xml node.Arguments
- Xml xml - Xml node.
Return value
1 if the state is saved successfully; otherwise, 0.void engine.render.setEnvironmentHazeGradient ( int gradient ) #
Console: render_environment_haze_gradient
Sets the environment haze gradient mode.Arguments
- int gradient - Haze gradient mode:
- 0 should be used for short distance range (e.g. near-surface haze).
- 1 should be used for long distance range (e.g. hazy mountains).
- 2 should be used for physically based haze simulation.
int engine.render.getEnvironmentHazeGradient ( ) #
Console: render_environment_haze_gradient
Returns the current environment haze gradient mode.Return value
Haze gradient mode:- 0 for short distance range (e.g. near-surface haze).
- 1 for long distance range (e.g. hazy mountains).
- 2 for physically based haze simulation.
vec4 engine.render.getEnvironmentHazeColor ( ) #
Returns the current haze color for the preset that overlays the other ones.Notice
To get the haze color for the specific preset, use
RenderEnvironmentPreset::getHazeColor(). This function will return color only if the RENDER_HAZE_SOLID mode is set via setEnvironmentHazeMode().
Source code (UnigineScript)
// get a haze color for the preset that overlays the others
engine.render.getEnvironmentHazeColor();
// get a haze color for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getHazeColor();Return value
Haze color.float engine.render.getEnvironmentHazeDensity ( ) #
Returns the haze density set for the preset that overlays the other ones. To get the haze density for the specific preset, use RenderEnvironmentPreset::getHazeDensity().Source code (UnigineScript)
// get a haze density for the preset that overlays the others
engine.render.getEnvironmentHazeDensity();
// get a haze density for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getHazeDensity();Return value
Haze density.float engine.render.getEnvironmentHazeMaxDistance ( ) #
Returns the distance starting at which the haze becomes completely solid, so nothing will be seen behind. To get the haze maximum visibility distance for the specific preset, use RenderEnvironmentPreset.getHazeMaxDistance().Source code (UnigineScript)
// get a haze maximum visibility distance for the preset that overlays the others
engine.render.getEnvironmentHazeMaxDistance();
// get a haze maximum visibility distance for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getHazeMaxDistance();Return value
Haze maximum visibility distance.float engine.render.getEnvironmentHazePhysicalStartHeight ( ) #
Returns the current reference height value for the two parameters (Half Visibility Distance and Half Faloff Height). To get the current reference height value for the specific preset, use RenderEnvironmentPreset::getHazePhysicalStartHeight().Source code (C++)
Returns the current reference height value for the two parameters (Half Visibility Distance and Half Faloff Height). To get the current reference height value for the specific preset, use RenderEnvironmentPreset.getHazePhysicalStartHeight(). // get a reference height value for the preset that overlays the others
Render::getEnvironmentHazePhysicalStartHeight();
// get a reference height value for the second environment preset
RenderEnvironmentPresetPtr preset = Render::getEnvironmentPreset(1);
preset->getHazePhysicalStartHeight();Source code (UnigineScript)
// get a reference height value for the preset that overlays the others
engine.render.getEnvironmentHazePhysicalStartHeight();
// get a haze reference height value for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getHazePhysicalStartHeight();Return value
Current reference height value, in units.float engine.render.getEnvironmentHazePhysicalHalfVisibilityDistance ( ) #
Returns the current distance to the boundary at which the visibility comprises 50%. There is no zero-visibility in the real world, so the half-visibility boundary is used to adjust haze distance.Return value
Current distance to the boundary at which the visibility comprises 50%, in units.float engine.render.getEnvironmentHazePhysicalHalfFalloffHeight ( ) #
Returns the current height of the haze density gradient. The higher the value, the longer the haze desity reduces as the height grows, making the transition between the clear sky and haze smoother.Return value
Current height of the haze density gradient.float engine.render.getEnvironmentHazePhysicalAmbientLightIntensity ( ) #
Returns the current intensity of the impact of the ambient lighting on haze (how much the ambient lighting affects the haze).Return value
Current value of intensity of the ambient lighting impact.float engine.render.getEnvironmentHazePhysicalAmbientColorSaturation ( ) #
Returns the current intensity of the ambient color's contribution to the haze (how much the sunlight affects the haze).Return value
Current value of intensity of the ambient color's contribution to the haze.float engine.render.getEnvironmentHazePhysicalSunLightIntensity ( ) #
Returns the current intensity of the impact of the sunlight on haze defining how much the sunlight affects the haze.Return value
Current value of intensity of the sunlight impact.float engine.render.getEnvironmentHazePhysicalSunColorSaturation ( ) #
Returns the current intensity of the impact of the sunlight on haze (how much the sunlight affects the haze).Return value
Current intensity of the sunlight color's contribution to the haze.float engine.render.getEnvironmentSkyIntensity ( ) #
Returns the intensity of the environment sky set for the preset that overlays the other ones. To get the sky intensity for the specific preset, use RenderEnvironmentPreset::getSkyIntensity().Source code (UnigineScript)
// get a sky intensity for the preset that overlays the others
engine.render.getEnvironmentSkyIntensity();
// get a sky intensity for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getSkyIntensity();Return value
Intensity value of the environment sky.float engine.render.getEnvironmentReflectionIntensity ( ) #
Returns the intensity of the environment reflections for the preset that overlays the other ones. 0 value means no environment reflections for the preset. To get the reflection intensity for the specific preset, use RenderEnvironmentPreset::getReflectionIntensity().Source code (UnigineScript)
// get a reflection intensity for the preset that overlays the others
engine.render.getEnvironmentReflectionIntensity();
// get a reflection intensity for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getReflectionIntensity();Return value
The intensity value of the environment reflections.float engine.render.getEnvironmentAmbientIntensity ( ) #
Returns the intensity of the environment ambient lighting for the preset that overlays the other ones. 0 value means no environment ambient lighting for the preset. The higher the value, the more ambient lighting affects environment. To get the ambient intensity for the specific preset, use RenderEnvironmentPreset::getAmbientIntensity().Source code (UnigineScript)
// get an ambient intensity for the preset that overlays the others
engine.render.getEnvironmentAmbientIntensity();
// get an ambient intensity for the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
preset.getAmbientIntensity();Return value
The intensity value of environment ambient lighting. The value can be greater than 1.0f.RenderEnvironmentPreset engine.render.getEnvironmentPreset ( int num ) #
Returns the environment preset of the given number.Source code (UnigineScript)
// get the second environment preset
RenderEnvironmentPreset preset = engine.render.getEnvironmentPreset(1);
// print the sky intensity of the obtained preset
log.message("%f\n", preset.getSkyIntensity());Arguments
- int num - The number of the environment preset. The value is clamped to the [0;2] range.
Return value
Environment preset.int engine.render.getTAASamples ( ) #
Console: render_taa_samples
Returns the number of the sample offsets performed during sub pixel jittering. By the minimum value of 1, there is no offsets, and, therefore, no anti-aliasing.Return value
The number of the sample offsets:- 0 - 1 offset
- 1 - 4 offsets
- 2 - 8 offsets
- 3 - 16 offsets
int engine.render.isFXAA ( ) #
Console: render_fxaa
Returns the value indicating if FXAA (post-process anti-aliasing) is enabled.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Return value
1 if FXAA is enabled; otherwise, 0.void engine.render.setTAACatmullResampling ( int resampling ) #
Console: render_taa_catmull_resampling
Toggles Catmull-Rom resampling on and off. The option allows you to reduce image blurring when the camera moves forward/backward. It is recommended to disable resampling at low settings.Arguments
- int resampling - 1 to enable Catmull-Rom resampling, 0 to disable it.
int engine.render.isTAA ( ) #
Console: render_taa
Returns the value indicating if TAA is enabled.Return value
1 if TAA is enabled; otherwise, 0.void engine.render.setTAASamples ( int samples ) #
Console: render_taa_samples
Sets the number of the sample offsets performed during sub pixel jittering. By the minimum value of 1, there will be no offsets, and, therefore, no anti-aliasing. The parameter allows reducing image jittering and blurring.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int samples - The number of the sample offsets:
- 0 - 1 offset
- 1 - 4 offsets
- 2 - 8 offsets
- 3 - 16 offsets
void engine.render.setTAAPixelOffset ( float offset ) #
Console: render_taa_pixel_offset
Sets the size of the sample offset performed during sub pixel jittering. You can specify the offset that is less than a pixel: for example, if you specify 0.5, frames will shift to half a pixel. It reduces image jittering and blurring.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float offset - Size of the sample offset.
int engine.render.isTAACatmullResampling ( ) #
Console: render_taa_catmull_resampling
Returns the value indicating if Catmull-Rom resampling is enabled. The option allows you to reduce image blurring when the camera moves forward/backward. It is recommended to disable resampling at low settings.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if Catmull-Rom resampling is enabled; otherwise, 0.void engine.render.setTAA ( int taa ) #
Console: render_taa
Toggles TAA on and off.Arguments
- int taa - 1 to enable TAA, 0 to disable it.
void engine.render.setFXAA ( int fxaa ) #
Console: render_fxaa
Toggles FXAA (post-process anti-aliasing) on and off.Arguments
- int fxaa - 1 to enable FXAA, 0 to disable it.
float engine.render.getTAAPixelOffset ( ) #
Console: render_taa_pixel_offset
Returns the size of the sample offset performed during sub pixel jittering. The offset can be less than a pixel: for example, if 0.5 is set, frames will shift to half a pixel.Return value
Size of the sample offset.int engine.render.isCameraEffectsTemporalFiltering ( ) #
Returns the value indicating if temporal filtering is enabled. Temporal filtering reduces flickering of the bloom effect on the small bright objects (such flickering may appear when the camera moves). For example, it can be used in scenes with industrial pipes.Return value
1 if temporal filtering is enabled; otherwise, 0.void engine.render.setCameraEffectsTemporalFiltering ( int filtering ) #
Toggles temporal filtering on and off. Temporal filtering reduces flickering of the bloom effect on the small bright objects (such flickering may appear when the camera moves). For example, it can be used in scenes with industrial pipes.Arguments
- int filtering - 1 to enable temporal filtering; 0 to disable it.
void engine.render.setSSBevelQuality ( int quality ) #
Console: render_ssbevel_quality
Sets the quality mode for the screen-space bevels.Arguments
- int quality - The quality mode:
- 0 - low
- 1 - medium (by default)
- 2 - high
int engine.render.isSSBevel ( ) #
Console: render_ssbevel
Returns the value indicating if the screen-space bevels are enabled.Return value
1 if the effect is enabled; otherwise, 0.float engine.render.getSSBevelRadius ( ) #
Console: render_ssbevel_radius
Returns the current size of the screen-space bevel effect.Return value
Size of the bevel effect in range [0.0f; 10.0f]. The default value is 10.0f.void engine.render.setSSBevelVertexNormal ( int normal ) #
Console: render_ssbevel_vertex_normal
Sets the mode of the screen-space bevels rendering:
- Better Edges smooths vertex and surface normals of the object. In this mode, the relief created by using Normal Mapping will be smoothed along with the mesh edges.
- Better Normals smooths only vertex normals. In this mode, only edges of the mesh geometry will be bevelled.
Arguments
- int normal - The mode of bevels rendering:
- 0 - the Better Edges mode.
- 1 - the Better Normals mode.
void engine.render.setSSBevel ( int bevel ) #
Console: render_ssbevel
Sets the value indicating if the screen-space bevels are enabled.Arguments
- int bevel - 1 to enable the effect, 0 to disable it.
void engine.render.setSSBevelRadius ( float radius ) #
Console: render_ssbevel_radius
Sets the size of the screen-space bevel effect.Arguments
- float radius - Size of the bevel effect in range [0.0f; 10.0f]. The default value is 10.0f.
int engine.render.getSSBevelVertexNormal ( ) #
Console: render_ssbevel_vertex_normal
Returns the current mode of the screen-space bevels rendering:
- Better Edges smooths vertex and surface normals of the object. In this mode, the relief created by using Normal Mapping will be smoothed along with the mesh edges.
- Better Normals smooths only vertex normals. In this mode, only edges of the mesh geometry will be bevelled.
Return value
The mode of bevels rendering:- 0 - the Better Edges mode.
- 1 - the Better Normals mode.
int engine.render.getSSBevelQuality ( ) #
Console: render_ssbevel_quality
Returns the current quality mode for the screen-space bevels.Return value
The quality mode:- 0 - low
- 1 - medium (by default)
- 2 - high
int engine.render.isSSBevelNoise ( ) #
Console: render_ssbevel_noise
Returns the value indicating if the noise that smooths bevels is enabled. It is recommended to use the noise with TAA enabled to avoid visual artifacts. The bevel noise is applied at a certain distance from the camera (i.e. if the camera is too far from the object with bevels, the noise won't be applied).Return value
1 if smoothing is enabled; otherwise, 0.void engine.render.setSSBevelNoise ( int noise ) #
Console: render_ssbevel_noise
Sets the value indicating if the noise that smooths bevels is enabled. It is recommended to use the noise with TAA enabled to avoid visual artifacts. The bevel noise is applied at a certain distance from the camera (i.e. if the camera is too far from the object with bevels, the noise won't be applied).Arguments
- int noise - 1 to enable smoothing, 0 to disable it.
void engine.render.setMaxFPS ( float maxfps ) #
Console: render_max_fps
Sets a maximum FPS value, to which rendering FPS is to be clamped.Arguments
- float maxfps - Maximum FPS value for clamping. 0 - disables FPS clamping. The default value is 0.
float engine.render.getMaxFPS ( ) #
Console: render_max_fps
Returns the current maximum FPS value, to which rendering FPS is clamped.Return value
Current maximum FPS value for clamping. 0 - FPS clamping is disabled.void engine.render.setCameraMode ( int mode ) #
Console: render_camera_mode
Sets the camera mode: classic or physically-based.
- If the physically-based camera mode is set, the real-world values are used to set up lighting and camera exposure: ISO, shutter speed, F-stop. At default values of these parameters, the static exposure value is near 1.
NoticeFor the physically-based mode, the exposure mode should be set to Static to avoid exposure issues.
- If the classic mode is set, the exposure is set by setExposure().
Arguments
- int mode - 0 for the classic camera mode; 1 for the physically-based camera mode.
int engine.render.getCameraMode ( ) #
Console: render_camera_mode
Returns the current camera mode: classic or physically-based.
- If the physically-based camera mode is set, the real-world values are used to set up lighting and camera exposure: ISO, shutter speed, F-stop. At default values of these parameters, the static exposure value is near 1.
NoticeFor the physically-based mode, the exposure mode should be set to Static to avoid exposure issues.
- If the classic mode is set, the exposure is set by setExposure().
Return value
0 if the classic camera mode is set; 1 if the physically-based camera mode is set.void engine.render.setISO ( float iso ) #
Console: render_iso
Sets an ISO for static exposure calculation.Arguments
- float iso - ISO value.
float engine.render.getISO ( ) #
Console: render_iso
Returns the ISO used for static exposure calculation.Return value
ISO value.void engine.render.setShutterSpeed ( float speed ) #
Console: render_shutter_speed
Sets a shutter speed for static exposure calculation.Arguments
- float speed - Shutter speed.
float engine.render.getShutterSpeed ( ) #
Console: render_shutter_speed
Sets the shutter speed used for static exposure calculation.Return value
Shutter speed.void engine.render.setFStop ( float fstop ) #
Console: render_f_stop
Sets an F-stop value for static exposure calculation.Arguments
- float fstop - F-stop value.
float engine.render.getFStop ( ) #
Console: render_f_stop
Returns the F-stop value used for static exposure calculation.Return value
F-stop value.void engine.render.setDepthPrePass ( int pass ) #
Console: render_depth_pre_pass
Enables or disables depth pre-pass rendering. When enabled, an additional depth buffer rendering pass is performed in the beginning of the rendering sequence.
Notice
This option can be used to gain performance for well optimized scenes using LODs and having a low-to-medium number of triangles in case of GPU bottlenecks. In other cases (heavy CAD models, large number of triangles and CPU bottlenecks) it may reduce performance, so it is recommended to use profiling tools to make sure that a positive effect is obtained.
Arguments
- int pass - 1 to enable depth pre-pass, 0 to disable it. The default value is 0.
int engine.render.isDepthPrePass ( ) #
Console: render_depth_pre_pass
Returns a value indicating if depth pre-pass rendering is enabled. When enabled, an additional depth buffer rendering pass is performed in the beginning of the rendering sequence.
Notice
This option can be used to gain performance for well optimized scenes using LODs and having a low-to-medium number of triangles in case of GPU bottlenecks. In other cases (heavy CAD models, large number of triangles and CPU bottlenecks) it may reduce performance, so it is recommended to use profiling tools to make sure that a positive effect is obtained.
Return value
1 if depth pre-pass rendering is enabled; otherwise, 0.void engine.render.setStereoHiddenArea ( int area ) #
Console: render_stereo_hidden_area
Sets culling mode for pixels, that are not visible in VR mode. This parameter is used for performance optimization.Arguments
- int area - Culling mode for pixels that are not visible in VR mode. One of the following values:
- 0 - hidden area culling is disabled (by default).
- 1 - OpenVR-based culling mode. Culling is performed using meshes returned by OpenVR.
NoticeCulling result depends on HMD used.
- 2 - Custom culling mode. Culling is performed using mesehes returned by OpenVR and an oval or circular mesh determined by custom adjustable parameters (See the setStereoHiddenAreaTransform() method.
int engine.render.getStereoHiddenArea ( ) #
Console: render_stereo_hidden_area
Returns the current culling mode for pixels, that are not visible in VR mode. This parameter is used for performance optimization.Return value
Current culling mode for pixels that are not visible in VR mode. One of the following values:- 0 - hidden area culling is disabled (by default).
- 1 - OpenVR-based culling mode. Culling is performed using meshes returned by OpenVR.
NoticeCulling result depends on HMD used.
- 2 - Custom culling mode. Culling is performed using meshes returned by OpenVR and an oval or circular mesh determined by custom adjustable parameters (See the setStereoHiddenAreaTransform() method.
void engine.render.setStereoHiddenAreaExposureTransform ( vec4 transform ) #
Sets the area to be used for exposure calculation, when culling of pixels, that are not visible in VR mode, is used. Correction of this area is used to avoid visual artefacts when clipped pixels affect exposure in visible areas.Arguments
- vec4 transform - Four-component vector (X, Y, Z, W), that determines a rectangular area to be used for exposure calculation, when culling of pixels, that are not visible in VR mode, is used:
- First two components (X, Y) - sizes along the X and Y axes respectively.
- Second two components (Z, W) - offset values along the X and Y axes respectively.
NoticeThese components are ignored when hidden area culling mode is set to 2
vec4 engine.render.getStereoHiddenAreaExposureTransform ( ) #
Sets the area to be used for exposure calculation, when culling of pixels, that are not visible in VR mode, is used. Correction of this area is used to avoid visual artefacts when clipped pixels affect exposure in visible areas.Return value
Four-component vector (X, Y, Z, W), that determines a rectangular area to be used for exposure calculation, when culling of pixels, that are not visible in VR mode, is used:- First two components (X, Y) - sizes along the X and Y axes respectively.
- Second two components (Z, W) - offset values along the X and Y axes respectively.
NoticeThese components are ignored when hidden area culling mode is set to 2
void engine.render.setStereoHiddenAreaTransform ( vec4 transform ) #
Console: render_stereo_hidden_area_transform
Sets the size and offset parameters for a new oval or circular mesh to be used for culling pixels, that are not visible in VR mode.
Notice
This custom circular mesh is used only when hidden area culling mode is set to 2.
Arguments
- vec4 transform - Four-component vector (X, Y, Z, W), that determines an area to be used for exposure calculation, when culling of pixels, that are not visible in VR mode, is used:
- First two components (X, Y) - sizes along the X and Y axes respectively.
- Second two components (Z, W) - offset values along the X and Y axes respectively.
NoticeThese components are ignored when hidden area culling mode is set to 2
vec4 engine.render.getStereoHiddenAreaTransform ( ) #
Console: render_stereo_hidden_area_transform
Returns the current size and offset parameters for an oval or circular mesh used for culling pixels, that are not visible in VR mode.
Notice
This custom circular mesh is used only when hidden area culling mode is set to 2.
Return value
Four-component vector (X, Y, Z, W), that determines an oval or circular mesh used for culling pixels, that are not visible in VR mode:- First two components (X, Y) - sizes along the X and Y axes respectively.
- Second two components (Z, W) - offset values along the X and Y axes respectively.
void engine.render.setTAAAntialiasingInMotion ( int motion ) #
Console: render_taa_antialiasing_in_motion
Sets a value indicating if improved anti-aliasing in motion (for moving camera and objects) is enabled.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int motion - 1 to enable improved anti-aliasing in motion (for moving camera and objects), 0 to disable it. The default value is 0.
int engine.render.isTAAAntialiasingInMotion ( ) #
Console: render_taa_antialiasing_in_motion
Returns a value indicating if improved anti-aliasing in motion (for moving camera and objects) is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if improved anti-aliasing in motion (for moving camera and objects) is enabled; otherwise, 0.void engine.render.setWhiteBalance ( int balance ) #
Console: render_white_balance
Sets a value indicating if automatic white balance correction is enabled.Arguments
- int balance - 1 to enable automatic white balance correction, 0 to disable it. The default value is 1.
int engine.render.isWhiteBalance ( ) #
Console: render_white_balance
Returns a value indicating if automatic white balance correction is enabled.Return value
1 if automatic white balance correction is enabled; otherwise, 0.void engine.render.setWhiteBalanceIntensity ( float intensity ) #
Console: render_white_balance_intensity
Sets the value of white balance correction intensity.Arguments
- float intensity - White balance correction intensity value in the range [0.0f, 1.0f]. The default value is 0.3f.
- By the minimum value of 0.0f, no white balance correction is performed.
- The higher the value, the stronger correction will be.
NoticeDo not set too high values for night-time and dimly lit scenes, as it may lead to heavy color distortion making the scene look totally unnatural.
float engine.render.getWhiteBalanceIntensity ( ) #
Console: render_white_balance_intensity
Returns the current value of white balance correction intensity.Return value
Current white balance correction intensity value in the range [0.0f, 1.0f]. The default value is 0.3f.void engine.render.setWhiteBalanceAdaptationTime ( float time ) #
Console: render_white_balance_adaptation_time
Sets the time for the camera to adjust white balance.Arguments
- float time - Time period, in seconds, during which white balance correction is performed. If 0.0f is set, instant correction will be used. The default value is 1.0f.
NoticeIt is recommended to use lower values, when possible, to make correction process unnoticeable, otherwise it'll be slow and will catch user's eye. However, setting too low values may result in abrupt switching of colors as the camera moves. So, adjust this parameter carefully to make transition smoooth. You can set it equal to the Exposure Adaptation value.
float engine.render.getWhiteBalanceAdaptationTime ( ) #
Console: render_white_balance_adaptation_time
Returns the current the time set for the camera to adjust white balance.Return value
Time period, in seconds, during which white balance correction is performed. If 0.0f is set, instant correction will be used. The default value is 1.0f.void engine.render.setSSDirt ( int dirt ) #
Console: render_ssdirt
Sets the value indicating if the Screen-Space Dirt (SSDirt) effect is enabled.Arguments
- int dirt - 1 to enable the SSDirt effect, 0 to disable it.
int engine.render.isSSDirt ( ) #
Console: render_ssdirt
Returns the value indicating if the Screen-Space Dirt (SSDirt) effect is enabled.Return value
1 if the SSDirt effect is enabled; otherwise, 0.void engine.render.setSSDirtAngleBias ( float bias ) #
Console: render_ssdirt_angle_bias
Sets the angle bias value to limit the SSDirt effect where information cannot be obtained. This parameter can be used to remove visual artefacts at the edges of polygons. The SSDirt effect must be enabled (see the setSSDirt() method).
Notice
This parameter affects both, concave and convex areas.
Arguments
- float bias - Angle bias value to be set in the range [0.0f; 1.0f]. The default value is 0.35f.
float engine.render.getSSDirtAngleBias ( ) #
Console: render_ssdirt_angle_bias
Sets the angle bias value to limit the SSDirt effect where information cannot be obtained. This parameter can be used to remove visual artefacts at the edges of polygons. The SSDirt effect must be enabled (see the setSSDirt() method).
Notice
This parameter affects both, concave and convex areas.
Return value
Angle bias value in the range [0.0f; 1.0f].void engine.render.setSSDirtCavityAlbedoTextureName ( string name ) #
Sets the name of the albedo texture to be used for cavities. This texture defines dirt and dust color pattern for all cavities globally. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- string name - Name of the albedo texture to be used for cavities.
string engine.render.getSSDirtCavityAlbedoTextureName ( ) #
Returns the name of the albedo texture used for cavities. This texture defines dirt and dust color pattern for all cavities globally. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Name of the albedo texture used for cavities.void engine.render.setSSDirtCavityColor ( vec4 color ) #
Console: render_ssdirt_cavity_color
Sets the color multiplier for the Albedo texture used for cavities (global dirt and dust color pattern). The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- vec4 color - Color multiplier for the Albedo texture used for cavities. By default, the color is white.
vec4 engine.render.getSSDirtCavityColor ( ) #
Console: render_ssdirt_cavity_color
Returns the current color multiplier for the Albedo texture used for cavities (global dirt and dust color pattern). The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Color multiplier for the Albedo texture used for cavities.void engine.render.setSSDirtCavityExponent ( float exponent ) #
Console: render_ssdirt_cavity_exponent
Sets the exponent value that determines the rate of gradual change of intensity along the radius for cavities. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float exponent - Exponent value to be set for cavities. Lower values make gradual change of intensity smoother. The default value is 1.0f.
float engine.render.getSSDirtCavityExponent ( ) #
Console: render_ssdirt_cavity_exponent
Returns the current exponent value that determines the rate of gradual change of intensity along the radius for cavities. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Exponent value set for cavities. Lower values make gradual change of intensity smoother. The default value is 1.0f.void engine.render.setSSDirtCavityMetalness ( float metalness ) #
Console: render_ssdirt_cavity_metalness
Sets the metalness value for cavities. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float metalness - Metalness value for cavities in the range [0.0f, 1.0f]. When set to 0 (by default), the SSDirt effect does not modify metalness buffer in cavities.
float engine.render.getSSDirtCavityMetalness ( ) #
Console: render_ssdirt_cavity_metalness
Returns the current metalness value for cavities. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current metalness value for cavities in the range [0.0f, 1.0f]. When set to 0 (by default), the SSDirt effect does not modify metalness buffer in cavities.void engine.render.setSSDirtCavityMetalnessVisibility ( float visibility ) #
Sets the metalness visibility value for cavities. A multiplier that determines the degree of impact of the effect on metalness buffer. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float visibility - Metalness visibility value to be set for cavities in the range [0.0f, 1.0f]. The higherthe value the more metalness buffer is affected. The default value is 0.0f.
float engine.render.getSSDirtCavityMetalnessVisibility ( ) #
Returns the current metalness visibility value for cavities. A multiplier that determines the degree of impact of the effect on metalness buffer. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current metalness visibility value for cavities.void engine.render.setSSDirtCavityShadingTextureName ( string name ) #
Sets the name of the shading texture to be used for cavities. Red channel of this texture defines metalness pattern for all cavities globally (other channels are ignored). The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- string name - Name of the shading texture to be used for cavities.
string engine.render.getSSDirtCavityShadingTextureName ( ) #
Returns the name of the shading texture used for cavities. Red channel of this texture defines metalness pattern for all cavities globally (other channels are ignored). The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Name of the shading texture used for cavities.void engine.render.setSSDirtCavityTextureSize ( float size ) #
Console: render_ssdirt_cavity_texture_size
Sets the scaling factor for the textures used for cavities. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float size - Scaling factor to be set for the textures used for cavities. The default value is 1.0f
float engine.render.getSSDirtCavityTextureSize ( ) #
Console: render_ssdirt_cavity_texture_size
Returns the current scaling factor for the textures used for cavities. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current scaling factor for the textures used for cavities.void engine.render.setSSDirtConvexityAlbedoTextureName ( string name ) #
Sets the name of the albedo texture to be used for convexities. This texture defines wear and scratch color pattern for all convexities globally. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- string name - Name of the albedo texture to be used for convexities.
string engine.render.getSSDirtConvexityAlbedoTextureName ( ) #
Returns the name of the albedo texture used for convexities. This texture defines wear and scratch color pattern for all convexities globally. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Name of the albedo texture used for convexities.void engine.render.setSSDirtConvexityColor ( vec4 color ) #
Console: render_ssdirt_convexity_color
Sets the color multiplier for the Albedo texture used for convexities (global wear and scratch color pattern). The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- vec4 color - Color multiplier for the Albedo texture used for convexities. By default, the color is white.
vec4 engine.render.getSSDirtConvexityColor ( ) #
Console: render_ssdirt_convexity_color
Returns the current color multiplier for the Albedo texture used for convexities (global wear and scratch color pattern). The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Color multiplier for the Albedo texture used for convexities.void engine.render.setSSDirtConvexityExponent ( float exponent ) #
Console: render_ssdirt_convexity_exponent
Sets the exponent value that determines the rate of gradual change of intensity along the radius for convexities. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float exponent - Exponent value to be set for convexities. Lower values make gradual change of intensity smoother. The default value is 1.0f.
float engine.render.getSSDirtConvexityExponent ( ) #
Console: render_ssdirt_convexity_exponent
Returns the current exponent value that determines the rate of gradual change of intensity along the radius for convexities. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Exponent value set for convexities. Lower values make gradual change of intensity smoother. The default value is 1.0f.void engine.render.setSSDirtConvexityMetalness ( float metalness ) #
Console: render_ssdirt_convexity_metalness
Sets the metalness value for convexities. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float metalness - Metalness value for convexities in the range [0.0f, 1.0f]. When set to 0 (by default), the SSDirt effect does not modify metalness buffer in convex areas.
float engine.render.getSSDirtConvexityMetalness ( ) #
Console: render_ssdirt_convexity_metalness
Returns the current metalness value for convexities. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current metalness value for convexities in the range [0.0f, 1.0f]. When set to 0 (by default), the SSDirt effect does not modify metalness buffer in convex areas.void engine.render.setSSDirtConvexityMetalnessVisibility ( float visibility ) #
Sets the metalness visibility value for convexities. A multiplier that determines the degree of impact of the effect on metalness buffer. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float visibility - Metalness visibility value to be set for convexities in the range [0.0f, 1.0f]. The higherthe value the more metalness buffer is affected. The default value is 0.0f.
float engine.render.getSSDirtConvexityMetalnessVisibility ( ) #
Returns the current metalness visibility value for convexities. A multiplier that determines the degree of impact of the effect on metalness buffer. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current metalness visibility value for convexities.void engine.render.setSSDirtConvexityShadingTextureName ( string name ) #
Sets the name of the shading texture to be used for convexities. Red channel of this texture defines metalness pattern for all convexities globally (other channels are ignored). The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- string name - Name of the shading texture to be used for convexities.
string engine.render.getSSDirtConvexityShadingTextureName ( ) #
Returns the name of the shading texture used for convexities. Red channel of this texture defines metalness pattern for all convexities globally (other channels are ignored). The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Name of the shading texture used for convexities.void engine.render.setSSDirtConvexityTextureSize ( float size ) #
Console: render_ssdirt_convexity_texture_size
Sets the scaling factor for the textures used for convexities. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float size - Scaling factor to be set for the textures used for convexities. The default value is 1.0f
float engine.render.getSSDirtConvexityTextureSize ( ) #
Console: render_ssdirt_convexity_texture_size
Returns the current scaling factor for the textures used for convexities. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current scaling factor for the textures used for convexities.void engine.render.setSSDirtIncreaseAccuracy ( int accuracy ) #
Console: render_ssdirt_increase_accuracy
Enables or disables increased accuracy for the SSDirt effect. This option should be used to remove visual artefacts along the screen edges, in case if they appear. Otherwise, it should be disabled. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- int accuracy - 1 to enable increased accuracy for the SSDirt effect, 0 to disable it. The default value is 0.
int engine.render.isSSDirtIncreaseAccuracy ( ) #
Console: render_ssdirt_increase_accuracy
Returns a value indicating if increased accuracy for the SSDirt effect is enabled. This option should be used to remove visual artefacts along the screen edges, in case if they appear. Otherwise, it should be disabled. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
1 if increased accuracy for the SSDirt effect is enabled; otherwise, 0.void engine.render.setSSDirtIntensity ( float intensity ) #
Console: render_ssdirt_intensity
Sets the intensity of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float intensity - Intensity of the SSDirt effect.
- By the minimum value of 0.0f, the effect is not visible.
- Higher values make the effect more pronounced.
float engine.render.getSSDirtIntensity ( ) #
Console: render_ssdirt_intensity
Returns the current intensity of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current intensity of the SSDirt effect.- By the minimum value of 0.0f, the effect is not visible.
- Higher values make the effect more pronounced.
void engine.render.setSSDirtPerspective ( float perspective ) #
Console: render_ssdirt_perspective
Sets the perspective value,that determines the degree of impact of distance from the camera on the radius of the Screen-Space Dirt effect:
- 0.0f - radius of the effect is bound to screen space (it remains constant relative to screen size, regardless of the distance to the camera).
- 1.0f - radius of the effect is bound to world space (it remains the same relative to objects, i.e. gets smaller as the camera moves away from them).
Arguments
- float perspective - Perspective value to be set in the range [0.0f, 1.0f]. The default value is 0.02f
float engine.render.getSSDirtPerspective ( ) #
Console: render_ssdirt_perspective
Returns the current perspective value, that determines the degree of impact of distance from the camera on the radius of the Screen-Space Dirt effect:
- 0.0f - radius of the effect is bound to screen space (it remains constant relative to screen size, regardless of the distance to the camera).
- 1.0f - radius of the effect is bound to world space (it remains the same relative to objects, i.e. gets smaller as the camera moves away from them).
Return value
Current perspective value in the range [0.0f, 1.0f]. The default value is 0.02fvoid engine.render.setSSDirtQuality ( int quality ) #
Console: render_ssdirt_quality
Sets the quality for the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).
Notice
This parameter significantly affects performance, so choose it reasonably.
Arguments
- int quality - SSDirt effect quality to be set:
- 0 - low
- 1 - medium
- 2 - high (by default)
- 3 - ultra
int engine.render.getSSDirtQuality ( ) #
Console: render_ssdirt_quality
Returns the current quality of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current SSDirt effect quality:- 0 - low
- 1 - medium
- 2 - high (by default)
- 3 - ultra
void engine.render.setSSDirtRadius ( float radius ) #
Console: render_ssdirt_radius
Sets the size of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float radius - Size of the SSDirt effect to be set. The default value is 1.0f.
float engine.render.getSSDirtRadius ( ) #
Console: render_ssdirt_radius
Returns the current size of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).void engine.render.setSSDirtResolution ( int resolution ) #
Console: render_ssdirt_resolution
Sets the resolution of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).
Notice
This parameter significantly affects performance, so choose it reasonably.
Arguments
- int resolution - Resolution of the SSDirt effect to be set:
- 0 - quarter
- 1 - half (by default)
- 2 - full
int engine.render.getSSDirtResolution ( ) #
Console: render_ssdirt_resolution
Returns the current resolution of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current resolution of the SSDirt effect:- 0 - quarter
- 1 - half (by default)
- 2 - full
void engine.render.setSSDirtThreshold ( float threshold ) #
Console: render_ssdirt_threshold
Sets the threshold of the SSDirt effect. It determines depth limit for the SSDirt effect in areas where information cannot be obtained. The SSDirt effect must be enabled (see the setSSDirt() method).Arguments
- float threshold - SSDirt threshold value to be set in the range [0.0f; 1.0f]. Higher values make the effect less pronounced. The default value is 1.0f.
float engine.render.getSSDirtThreshold ( ) #
Console: render_ssdirt_threshold
Returns the current threshold value of the SSDirt effect. The SSDirt effect must be enabled (see the setSSDirt() method).Return value
Current SSDirt threshold value in the range [0.0f; 1.0f]. Higher values make the effect less pronounced. The default value is 1.0f.void engine.render.setLatency ( int latency ) #
Console: render_latency
Set the maximum number of back buffer frames that a driver is allowed to queue for rendering. The buffers are used for GPU load optimization: in certain cases several command buffers (frames) can be processed by GPU at once increasing the Waiting GPU time for one frame and having zero Waiting GPU time for the next ones. Thus, GPU avoids rendering spikes, but increased Waiting GPU time will cause a spike in application logic, in case when the logic is bound to duration of a single frame. Frame latency is the number of frames that are allowed to be stored in a queue before submission for rendering. Latency is often used to control how the CPU chooses between responding to user input and frames that are in the render queue. In certain cases (high GPU load, VSYNC usage) it may be required to queue more frames of data, it is also beneficial for applications with no user input (e.g., video playback).Arguments
- int latency - Maximum number of back buffer frames allowed:
- 0 - sequential rendering CPU-GPU-CPU-GPU...
- 1 - 1 buffer (by default)
- 2 - 2 buffers
- 3 - 3 buffers
NoticeValues 1-3 are available for DirectX only.
int engine.render.getLatency ( ) #
Console: render_latency
Returns the maximum number of back buffer frames that a driver is allowed to queue for rendering. The buffers are used for GPU load optimization: in certain cases several command buffers (frames) can be processed by GPU at once increasing the Waiting GPU time for one frame and having zero Waiting GPU time for the next ones. Thus, GPU avoids rendering spikes, but increased Waiting GPU time will cause a spike in application logic, in case when the logic is bound to duration of a single frame. Frame latency is the number of frames that are allowed to be stored in a queue before submission for rendering. Latency is often used to control how the CPU chooses between responding to user input and frames that are in the render queue. In certain cases (high GPU load, VSYNC usage) it may be required to queue more frames of data, it is also beneficial for applications with no user input (e.g., video playback).Return value
Maximum number of back buffer frames currently allowed:- 0 - sequential rendering CPU-GPU-CPU-GPU...
- 1 - 1 buffer (by default)
- 2 - 2 buffers
- 3 - 3 buffers
Notice
Values 1-3 are available for DirectX only.
void engine.render.setStreamingMode ( int mode ) #
Console: render_streaming_mode
Sets the streaming mode to be used for textures and meshes. Forced mode can be used for grabbing frame sequences, rendering node previews, etc.Arguments
- int mode - Streaming mode to be set: one of the RENDER_STREAMING_* variables.
int engine.render.getStreamingMode ( ) #
Console: render_streaming_mode
Returns the current streaming mode used for textures and meshes.Return value
Current streaming mode: one of the RENDER_STREAMING_* variables.void engine.render.setStreamingUseMemoryLimit ( int limit ) #
Console: render_streaming_use_memory_limit
Sets a value indicating if memory limitation for asynchronous resource loading (meshes and textures) is enabled.Arguments
- int limit - 1 to enable memory limitation for asynchronous resource loading (meshes and textures), 0 to disable it. The default value is 1.
int engine.render.isStreamingUseMemoryLimit ( ) #
Console: render_streaming_use_memory_limit
Returns a value indicating if memory limitation for asynchronous resource loading (meshes and textures) is currently enabled.Return value
1 if memory limitation for asynchronous resource loading (meshes and textures) is currently enabled; otherwise, 0.void engine.render.setStreamingMaxThreads ( int threads ) #
Console: render_streaming_max_threads
Set the maximum number of threads used for streaming.Arguments
- int threads - Maximum number of threads to be used for streaming, within the [1; 256] range. The default value is 1.
NoticeHigher number of threads results in faster streaming, but may cause spikes in case of excessive consumption of GPU resources.
int engine.render.getStreamingMaxThreads ( ) #
Console: render_streaming_max_threads
Returns the maximum number of threads used for streaming.Return value
Current maximum number of threads used for streaming, within the [1; 256] range. The default value is 1.Notice
Higher number of threads results in faster streaming, but may cause spikes in case of excessive consumption of GPU resources.
void engine.render.setStreamingDestroyDuration ( int duration ) #
Console: render_streaming_destroy_duration
Sets resource cleanup interval.Arguments
- int duration - Resource cleanup interval, in number of frames, within the [0; 300] range. The default value is 30.
int engine.render.getStreamingDestroyDuration ( ) #
Console: render_streaming_destroy_duration
Returns the current resource cleanup interval.Return value
Resource cleanup interval, in number of frames, within the [0; 300] range.void engine.render.setStreamingParticlesMemoryLimit ( int limit ) #
Sets cache memory limit used for streaming of vertices of particle systems.Arguments
- int limit - Cache memory limit for vertices of particle systems to be set, in percentage of the total GPU memory. The default value is 3.
int engine.render.getStreamingParticlesMemoryLimit ( ) #
Returns the current cache memory limit used for streaming of vertices of particle systems.Return value
Current cache memory limit for vertices of particle systems, in percentage of the total GPU memory.void engine.render.setStreamingTexturesMemoryLimit ( int limit ) #
Sets cache memory limit used for texture streaming.Arguments
- int limit - Cache memory limit for textures to be set, in percentage of the total GPU memory. The default value is 65.
int engine.render.getStreamingTexturesMemoryLimit ( ) #
Returns the current cache memory limit used for texture streaming.Return value
Current cache memory limit for textures, in percentage of the total GPU memory.void engine.render.setStreamingTexturesCacheResolution ( int resolution ) #
Sets resolution for texture cache elements. These minimized copies of textures are used instead of the originals.Arguments
- int resolution - Resolution for texture cache elements. One of the following values:
- 0 - is 8x8
- 1 - is 16x16 (by default)
- 2 - is 32x32
- 3 - is 64x64
- 4 - is 128x128
- 5 - is 256x256
- 6 - is 512x512
int engine.render.getStreamingTexturesCacheResolution ( ) #
Returns current resolution for texture cache elements. These minimized copies of textures are used instead of the originals.Return value
Current resolution for texture cache elements. One of the following values:- 0 - is 8x8
- 1 - is 16x16 (by default)
- 2 - is 32x32
- 3 - is 64x64
- 4 - is 128x128
- 5 - is 256x256
- 6 - is 512x512
void engine.render.setStreamingMeshesMemoryLimit ( int limit ) #
Console: render_streaming_meshes_memory_limit
Sets cache memory limit used for mesh streaming.Arguments
- int limit - Cache memory limit for meshes to be set, in percentage of the total GPU memory. The default value is 15.
int engine.render.getStreamingMeshesMemoryLimit ( ) #
Console: render_streaming_meshes_memory_limit
Returns the current cache memory limit used for mesh streaming.Return value
Current cache memory limit for meshes, in percentage of the total GPU memory.void engine.render.setShadersPreload ( int preload ) #
Console: render_shaders_preload
Sets a value indicating if all shaders are compiled and loaded to RAM every time the world is loaded.
Notice
Pre-loading shaders results in significant memory consumption. It is recommended to use pre-generated shaders cache instead when possible (see the shaders_create command). In this case necessary shaders are loaded from cache to RAM on demand.
Arguments
- int preload - 1 to enable pre-loading for shaders, 0 to disable it. The default value is 0.
int engine.render.isShadersPreload ( ) #
Console: render_shaders_preload
Returns a value indicating if all shaders are compiled and loaded to RAM every time the world is loaded.
Notice
Pre-loading shaders results in significant memory consumption. It is recommended to use pre-generated shaders cache instead when possible (see the shaders_create command). In this case necessary shaders are loaded from cache to RAM on demand.
Return value
1 if pre-loading for shaders is enabled; otherwise, 0.void engine.render.destroyCacheTexture ( UGUID guid ) #
Deletes cache (images and metadata) stored on disk for the texture with the specified GUID. Corresponding files in the data/.cache_textures will be removed.Arguments
- UGUID guid - Texture file GUID.
void engine.render.createCacheTexture ( UGUID guid ) #
Generates cache for the texture with the specified GUID.Notice
Texture cache generated by this method is incomplete, only images are created, as all metadata (flags, etc.) is stored in materials.
Arguments
- UGUID guid - Texture file GUID.
void engine.render.destroyCacheTextures ( ) #
Clears texture cache (images and metadata) stored on disk. All files in the data/.cache_textures will be removed.void engine.render.unloadCacheTextures ( ) #
Unloads texture cache from the memory. This method does not delete files in the data/.cache_textures.void engine.render.createCacheTextures ( ) #
Generates texture cache for all textures used in the project.Notice
Texture cache generated by this method is incomplete, only images are created, as all metadata (flags, etc.) is stored in materials.
void engine.render.loadCacheTextures ( ) #
Console: render_streaming_textures_cache_load
Loads texture cache from the disk. Texture cache always remains in memory after loading.void engine.render.setTranslucentColor ( vec4 color ) #
Console: render_translucent_color
Sets the color to be used for translucent objects globally. When light shines on one side of the object, the other side is partially illuminated with this color.Arguments
- vec4 color - Color to be used for translucent objects globally. By default, the color is white.
vec4 engine.render.getTranslucentColor ( ) #
Console: render_translucent_color
Returns the current color used for translucent objects globally. When light shines on one side of the object, the other side is partially illuminated with this color.Return value
Color used for translucent objects globally. By default, the color is white.void engine.render.setShadowDistanceScale ( float scale ) #
Console: render_shadow_distance_scale
Sets the global shadow distance scale multiplier. This option allows a developer to easily increase or decrease shadows rendering performance by changing the scale.Arguments
- float scale - Global shadow distance scale multiplier to be set in [0.0f; inf] range. The default value is 1.0f.
float engine.render.getShadowDistanceScale ( ) #
Console: render_shadow_distance_scale
Returns the current the global shadow distance scale multiplier. This option allows a developer to easily increase or decrease shadows rendering performance by changing the scale.Return value
Current global shadow distance scale multiplier in [0.0f; inf] range.void engine.render.addScriptableMaterial ( Material material ) #
Adds a new global scriptable material. To apply a scriptable material per-camera or per-player, use the addScriptableMaterial() method of the Camera class or the same method of the Player class respectively. The order of execution for scripts assigned to scriptable materials is defined by material's number in the list of materials applied globally.Notice
Scriptable materials applied globally have their expressions executed before the ones that are applied per-camera or per-player.
Arguments
- Material material - Scriptable material to be applied globally.
void engine.render.insertScriptableMaterial ( int num, Material material ) #
Inserts a new global scriptable material to the list of globally applied scriptable materials. To apply a scriptable material per-camera or per-player, use the insertScriptableMaterial() method of the Camera class or the same method of the Player class respectively. The order of execution for scripts assigned to scriptable materials is defined by material's number in the list of materials applied globally.Notice
Scriptable materials applied globally have their expressions executed before the ones that are applied per-camera or per-player.
Arguments
- int num - Position at which a new scriptable material is to be inserted.
- Material material - Scriptable material to be inserted into the list of globally applied scriptable materials.
void engine.render.removeScriptableMaterial ( int num ) #
Removes the global scriptable material with the specified number.Arguments
- int num - Scriptable material number in the range from 0 to the total number of scriptable materials.
int engine.render.getNumScriptableMaterials ( ) #
Returns the total number of scriptable materials applied globally.Return value
Total number of scriptable materials applied globally.int engine.render.findScriptableMaterial ( Material material ) #
Returns the number of the specified scriptable material applied globally. This number determines the order in which the assigned expressions are executed.Notice
Scriptable materials applied globally have their expressions executed before the ones that are applied per-camera or per-player.
Arguments
- Material material - Scriptable material for which a number is to be found.
Return value
Scriptable material number in the range from 0 to the total number of scriptable materials, or -1 if the specified material was not found.void engine.render.setScriptableMaterial ( int num, Material material ) #
Replaces the scriptable material with the specified number with the new scriptable material specified. The number of material determines the order in which the expressions assigned to it are executed.Notice
Scriptable materials applied globally have their expressions executed before the ones that are applied per-camera or per-player.
Arguments
- int num - Scriptable material number in the range from 0 to the total number of scriptable materials.
- Material material - New scriptable material to replace the one with the specified number.
Material engine.render.getScriptableMaterial ( int num ) #
Returns a scriptable material applied globally by its number.Arguments
- int num - Scriptable material number in the range from 0 to the total number of scriptable materials.
Return value
Scriptable material applied globally with the specified number.void engine.render.setScriptableMaterialEnabled ( int num, int enabled ) #
Enables or disables the scriptable material with the specified number. When a material is disabled (inactive), the scripts attached to it are not executed.Arguments
- int num - Scriptable material number in the range from 0 to the total number of scriptable materials.
- int enabled - 1 to enable the scriptable material with the specified number, 0 to disable it.
int engine.render.getScriptableMaterialEnabled ( int num ) #
Returns a value indicating if the scriptable material with the specified number is enabled (active). When a material is disabled (inactive), the scripts attached to it are not executed.Arguments
- int num - Scriptable material number in the range from 0 to the total number of scriptable materials.
Return value
1 if the scriptable material with the specified number is enabled; otherwise, 0.void engine.render.swapScriptableMaterials ( int num_0, int num_1 ) #
Swaps two scriptable materials with specified numbers. The number of material determines the order in which the expressions assigned to it are executed.Notice
Scriptable materials applied globally have their expressions executed before the ones that are applied per-camera or per-player.
Arguments
- int num_0 - Number of the first scriptable material in the range from 0 to the total number of scriptable materials.
- int num_1 - Number of the second scriptable material in the range from 0 to the total number of scriptable materials.
void engine.render.clearScriptableMaterials ( ) #
Clears all global scriptable materials.int engine.render.getHDRTextureFormat ( ) #
Returns the currently used HDR texture format.Return value
Current HDR texture format. One of the following values:Texture engine.render.getTemporaryTexture ( int width, int height, int format, int flags = 0, string name = 0 ) #
Allocates a temporary render texture with the specified width, height, format, and flags. This function can be used when you need a quick render texture to perform some temporary calculations. Release it using releaseTemporaryTexture() as soon as you're done with it, so another call can start reusing it, if necessary. In any case, such texture shall be released automatically in the next frame.
UNIGINE keeps an internal pool of temporary render textures, so a call to this method most often just returns an already created one (if the size and format match). These temporary textures are actually destroyed when they aren't used for a couple of frames.
If you are doing a series of post-processing "blits", it's best for performance to get and release a temporary render texture for each blit, instead of getting one or two render textures upfront and reusing them.
Notice
You can't depend on any particular contents of a temporary texture obtained from this function: it might be garbage, or it might be cleared to some color, depending on the platform.
It also automatically gives names to resources, which can be used for identification in debug.
Arguments
- int width - Width of the texture, in pixels.
- int height - Height of the texture, in pixels.
- int format - Texture format: one of the TEXTURE_FORMAT_* values.
- int flags - Texture flags.
- string name - Name to be used for this temporary texture (optional).
Return value
Temporary texture.Texture engine.render.getTemporaryTexture ( Texture texture ) #
Allocates a temporary render texture with the specified width, height, format, and flags. This function can be used when you need a quick render texture to perform some temporary calculations. Release it using releaseTemporaryTexture() as soon as you're done with it, so another call can start reusing it, if necessary. In any case, such texture shall be released automatically in the next frame.
UNIGINE keeps an internal pool of temporary render textures, so a call to this method most often just returns an already created one (if the size and format match). These temporary textures are actually destroyed when they aren't used for a couple of frames.
If you are doing a series of post-processing "blits", it's best for performance to get and release a temporary render texture for each blit, instead of getting one or two render textures upfront and reusing them.
Notice
You can't depend on any particular contents of a temporary texture obtained from this function: it might be garbage, or it might be cleared to some color, depending on the platform.
It also automatically gives names to resources, which can be used for identification in debug.
Arguments
- Texture texture - Source texture for which a temporary texture is to be allocated in the pool.
Return value
Temporary texture.Texture engine.render.getTemporaryTexture ( Texture texture, string name = 0 ) #
Allocates a temporary render texture for the specified source texture (using all its parameters: resolution, flags, etc.). This function can be used when you need a quick render texture to perform some temporary calculations. Release it using releaseTemporaryTexture() as soon as you're done with it, so another call can start reusing it, if necessary. In any case, such texture shall be released automatically in the next frame.
UNIGINE keeps an internal pool of temporary render textures, so a call to this method most often just returns an already created one (if the size and format match). These temporary textures are actually destroyed when they aren't used for a couple of frames.
If you are doing a series of post-processing "blits", it's best for performance to get and release a temporary render texture for each blit, instead of getting one or two render textures upfront and reusing them.
Notice
You can't depend on any particular contents of a temporary texture obtained from this function: it might be garbage, or it might be cleared to some color, depending on the platform.
It also automatically gives names to resources, which can be used for identification in debug.
Arguments
- Texture texture - Source texture for which a temporary texture is to be allocated in the pool.
- string name - Name to be used for this temporary texture (optional).
Return value
Temporary texture.Texture engine.render.getTemporary2DArrayTexture ( int width, int height, int depth, int format, int flags = 0, string name = 0 ) #
Allocates a temporary 2D array texture with the specified width, height, number of layers, format, and flags. This function can be used when you need a quick render texture to perform some temporary calculations. Release it using releaseTemporaryTexture() as soon as you're done with it, so another call can start reusing it, if necessary. In any case, such texture shall be released automatically in the next frame.
UNIGINE keeps an internal pool of temporary render textures, so a call to this method most often just returns an already created one (if the size and format match). These temporary textures are actually destroyed when they aren't used for a couple of frames.
If you are doing a series of post-processing "blits", it's best for performance to get and release a temporary render texture for each blit, instead of getting one or two render textures upfront and reusing them.
Notice
You can't depend on any particular contents of a temporary texture obtained from this function: it might be garbage, or it might be cleared to some color, depending on the platform.
Arguments
- int width - Width of the 2D array texture, in pixels.
- int height - Height of the 2D array texture, in pixels.
- int depth - Number of layers in the 2D array texture.
- int format - Texture format: one of the TEXTURE_FORMAT_* values.
- int flags - Texture flags.
- string name - Name to be used for this temporary 2D array texture (optional).
Return value
Temporary 2D array texture.Texture engine.render.getTemporary3DTexture ( int width, int height, int depth, int format, int flags = 0, string name = 0 ) #
Allocates a temporary 3D texture with the specified width, height, depth, format, and flags. This function can be used when you need a quick render texture to perform some temporary calculations. Release it using releaseTemporaryTexture() as soon as you're done with it, so another call can start reusing it, if necessary. In any case, such texture shall be released automatically in the next frame.
UNIGINE keeps an internal pool of temporary render textures, so a call to this method most often just returns an already created one (if the size and format match). These temporary textures are actually destroyed when they aren't used for a couple of frames.
If you are doing a series of post-processing "blits", it's best for performance to get and release a temporary render texture for each blit, instead of getting one or two render textures upfront and reusing them.
Notice
You can't depend on any particular contents of a temporary texture obtained from this function: it might be garbage, or it might be cleared to some color, depending on the platform.
Arguments
- int width - Width of the 3D texture, in pixels.
- int height - Height of the 3D texture, in pixels.
- int depth - Depth of the 3D texture, in pixels.
- int format - Texture format: one of the TEXTURE_FORMAT_* values.
- int flags - Texture flags.
- string name - Name to be used for this temporary 3D texture (optional).
Return value
Temporary 3D texture.void engine.render.releaseTemporaryTexture ( Texture texture ) #
Releases the temporary texture previously obtained via getTemporaryTexture(), getTemporary2DArrayTexture(), or getTemporary3DTexture() method and returns it to the pool.Arguments
- Texture texture - Temporary texture or texture array to be returned to the pool.
RenderTarget engine.render.getTemporaryRenderTarget ( ) #
Allocates a temporary render target. This function can be used when you need a quick render target to perform some temporary calculations. Release it using releaseTemporaryRenderTarget() as soon as you're done with it, so another call can start reusing it if necessary. In any case such render target shall be released automatically in the next frame.
UNIGINE keeps an internal pool of temporary render targets, so a call to this method most often just returns an already created one (if the size and format matches). These temporary render targets are actually destroyed when they aren't used for a couple of frames.
If you are doing a series of post-processing "blits", it's best for performance to get and release a temporary render targets for each blit, instead of getting one or two render targets upfront and reusing them.
Notice
You can't depend on any particular contents of a temporary render target obtained from this function: it might be garbage, or it might be cleared to some color, depending on the platform.
Return value
Temporary render target.void engine.render.releaseTemporaryRenderTarget ( RenderTarget render_target ) #
Releases the temporary render target previously obtained via getTemporaryRenderTarget() method and returns it to the pool.Arguments
- RenderTarget render_target - Temporary render target to be returned to the pool.
void engine.render.setLightsInterleavedSamples ( int samples ) #
Console: render_lights_interleaved_samples
Sets one of the two interleaved rendering modes defining the number of pixels to be skipped when rendering lights during the deferred pass with subsequent reconstruction of neighboring pixels using the data from previous frames.Arguments
- int samples - Interleaved rendering mode for lighting during the deferred pass to be set, one of the following:
- 0 - half of all pixels is rendered skipping each second line (1 x 2)
- 1 - quarter of all pixels is rendered skipping each second line and row (2 x 2)
int engine.render.getLightsInterleavedSamples ( ) #
Console: render_lights_interleaved_samples
Returns the current interleaved rendering mode defining the number of pixels to be skipped when rendering lights during the deferred pass with subsequent reconstruction of neighboring pixels using the data from previous frames.Return value
Current interleaved rendering mode for lighting during the deferred pass, one of the following:- 0 - half of all pixels is rendered skipping each second line (1 x 2)
- 1 - quarter of all pixels is rendered skipping each second line and row (2 x 2)
void engine.render.setSSAODenoiseQuality ( int quality ) #
Console: render_ssao_denoise_quality
Sets the noise reduction quality level for the SSAO (Screen-Space Ambient Occlusion) effect defining the number of samples used.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - Noise reduction quality to be set:
- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
int engine.render.getSSAODenoiseQuality ( ) #
Console: render_ssao_denoise_quality
Returns the current noise reduction quality level for the SSAO (Screen-Space Ambient Occlusion) effect defining the number of samples used.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current noise reduction quality:- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
void engine.render.setSSGIDenoiseQuality ( int quality ) #
Console: render_ssgi_denoise_quality
Sets the noise reduction quality level for the SSGI (Screen-Space Global Illumination) effect defining the number of samples used.Arguments
- int quality - Noise reduction quality to be set:
- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
int engine.render.getSSGIDenoiseQuality ( ) #
Console: render_ssgi_denoise_quality
Returns the current noise reduction quality level for the SSGI (Screen-Space Global Illumination) effect defining the number of samples used.Return value
Current noise reduction quality:- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
void engine.render.setSSGIDenoiseIntensity ( float intensity ) #
Console: render_ssgi_denoise_intensity
Sets the noise reduction intensity for the SSGI (Screen Space Global Illumination) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.
float engine.render.getSSGIDenoiseIntensity ( ) #
Console: render_ssgi_denoise_intensity
Returns the current noise reduction intensity for the SSGI (Screen Space Global Illumination) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Noise reduction intensity value in range [0.0f; 1.0f]. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.void engine.render.setSSGIDenoiseGaussianSigma ( float sigma ) #
Console: render_ssgi_denoise_gaussian_sigma
Sets the sigma parameter of Gaussian blur used for noise reduction for the SSGI (Screen Space Global Illumination) effect. This parameter controls the amount of blur applied.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float sigma - Gaussian blur sigma parameter value in range [0.0f; 100.0f] to be set. The default value is 10.0f.
float engine.render.getSSGIDenoiseGaussianSigma ( ) #
Console: render_ssgi_denoise_gaussian_sigma
Returns the current value of the sigma parameter of Gaussian blur used for noise reduction for the SSGI (Screen Space Global Illumination) effect. This parameter controls the amount of blur applied.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Gaussian blur sigma parameter value in range [0.0f; 100.0f]. The default value is 10.0f.void engine.render.setSSGIDenoiseThreshold ( float threshold ) #
Console: render_ssgi_denoise_threshold
Sets the threshold value for color difference of neighboring pixels used for noise reduction for the SSGI (Screen Space Global Illumination) effect: blur is applied when the color difference is less than the threshold value.
Notice
Setting too high values result in blurring the whole image.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f] to be set. The default value is 0.1f.
float engine.render.getSSGIDenoiseThreshold ( ) #
Console: render_ssgi_denoise_threshold
Returns the current threshold value for color difference of neighboring pixels used for noise reduction for the SSGI (Screen Space Global Illumination) effect: blur is applied when the color difference is less than the threshold value.
Notice
Setting too high values result in blurring the whole image.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f]. The default value is 0.1f.void engine.render.setSSGIDenoiseRadius ( int radius ) #
Console: render_ssgi_denoise_radius
Sets the radius of the area to be affected by noise reduction for the SSGI (Screen Space Global Illumination) effect.Arguments
- int radius - Radius to be affected by noise reduction, an integer value in range [1; 3] to be set. The default value is 1.
int engine.render.getSSGIDenoiseRadius ( ) #
Console: render_ssgi_denoise_radius
Returns the current radius of the area to be affected by noise reduction for the SSGI (Screen Space Global Illumination) effect.Return value
Radius to be affected by noise reduction, an integer value in range [1; 3]. The default value is 1.void engine.render.setSSGIColorClampingIntensity ( float intensity ) #
Console: render_ssgi_color_clamping_intensity
Sets the intensity of TAA color clamping at zero pixel velocity for the SSGI (Screen Space Global Illumination) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSGI Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.
float engine.render.getSSGIColorClampingIntensity ( ) #
Console: render_ssgi_color_clamping_intensity
Returns the current intensity of TAA color clamping at zero pixel velocity for the SSGI (Screen Space Global Illumination) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSGI Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.void engine.render.setSSGIColorClampingVelocityThreshold ( float threshold ) #
Sets the sensitivity of TAA color clamping for the SSGI (Screen Space Global Illumination) effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold for the intensity of TAA color clamping at zero pixel velocity.
float engine.render.getSSGIColorClampingVelocityThreshold ( ) #
Returns the current sensitivity of TAA color clamping for the SSGI (Screen Space Global Illumination) effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold for the intensity of TAA color clamping at zero pixel velocity.void engine.render.setBentNormalDenoiseQuality ( int quality ) #
Console: render_bent_normal_denoise_quality
Sets the noise reduction quality level for bent normals calculation defining the number of samples used.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - Noise reduction quality to be set:
- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
int engine.render.getBentNormalDenoiseQuality ( ) #
Console: render_bent_normal_denoise_quality
Returns the current noise reduction quality level for bent normals calculation defining the number of samples used.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current noise reduction quality:- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
void engine.render.setSSRDenoiseQuality ( int quality ) #
Console: render_ssr_denoise_quality
Sets the noise reduction quality level for the SSR (Screen-Space Reflections) effect defining the number of samples used.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int quality - Noise reduction quality to be set:
- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
int engine.render.getSSRDenoiseQuality ( ) #
Console: render_ssr_denoise_quality
Returns the current noise reduction quality level for the SSR (Screen-Space Reflections) effect defining the number of samples used.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current noise reduction quality:- 0 - Low
- 1 - Medium (by default)
- 2 - High
- 3 - Ultra
void engine.render.setSSRDenoiseIntensity ( float intensity ) #
Console: render_ssr_denoise_intensity
Sets the noise reduction intensity for the SSR (Screen-Space Reflections) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.
float engine.render.getSSRDenoiseIntensity ( ) #
Console: render_ssr_denoise_intensity
Returns the current noise reduction intensity for the SSR (Screen-Space Reflections) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.void engine.render.setSSRDenoiseGaussianSigma ( float sigma ) #
Console: render_ssr_denoise_gaussian_sigma
Sets the sigma parameter of Gaussian blur used for noise reduction for the SSR (Screen-Space Reflections) effect. This parameter controls the amount of blur applied.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float sigma - Gaussian blur sigma parameter value in range [0.0f; 100.0f] to be set. The default value is 10.0f.
float engine.render.getSSRDenoiseGaussianSigma ( ) #
Console: render_ssr_denoise_gaussian_sigma
Returns the current value of the sigma parameter of Gaussian blur used for noise reduction for the SSR (Screen-Space Reflections) effect. This parameter controls the amount of blur applied.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Gaussian blur sigma parameter value in range [0.0f; 100.0f]. The default value is 10.0f.void engine.render.setSSRDenoiseThreshold ( float threshold ) #
Console: render_ssr_denoise_threshold
Sets the threshold value for color difference of neighboring pixels used for noise reduction for the SSR (Screen-Space Reflections) effect: blur is applied when the color difference is less than the threshold value.
Notice
Setting too high values result in blurring the whole image.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f] to be set. The default value is 0.1f.
float engine.render.getSSRDenoiseThreshold ( ) #
Console: render_ssr_denoise_threshold
Returns the current threshold value for color difference of neighboring pixels used for noise reduction for the SSR (Screen-Space Reflections) effect: blur is applied when the color difference is less than the threshold value.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f]. The default value is 0.1f.void engine.render.setSSRDenoiseRadius ( int radius ) #
Console: render_ssr_denoise_radius
Sets the radius of the area to be affected by noise reduction for the SSR (Screen-Space Reflections) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int radius - Radius to be affected by noise reduction, an integer value in range [1; 3] to be set. The default value is 1.
int engine.render.getSSRDenoiseRadius ( ) #
Console: render_ssr_denoise_radius
Returns the current radius of the area to be affected by noise reduction for the SSR (Screen-Space Reflections) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Radius to be affected by noise reduction, an integer value in range [1; 3]. The default value is 1.void engine.render.setSSRColorClampingIntensity ( float intensity ) #
Console: render_ssr_color_clamping_intensity
Sets the intensity of TAA color clamping at zero pixel velocity for the SSR (Screen-Space Reflections) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSR Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.
float engine.render.getSSRColorClampingIntensity ( ) #
Console: render_ssr_color_clamping_intensity
Returns the current intensity of TAA color clamping at zero pixel velocity for the SSR (Screen-Space Reflections) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSR Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.void engine.render.setSSRColorClampingVelocityThreshold ( float threshold ) #
Sets the sensitivity of TAA color clamping for the SSR (Screen-Space Reflections) effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Sensitivity of TAA color clamping for the SSR (Screen-Space Reflections) effect to pixel velocity change in range [0.0f; 1.0f] to be set. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSR Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.
float engine.render.getSSRColorClampingVelocityThreshold ( ) #
Returns the current sensitivity of TAA color clamping for the SSR (Screen-Space Reflections) effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Sensitivity of TAA color clamping for the SSR (Screen-Space Reflections) effect to pixel velocity change in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSR Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.void engine.render.setSSSSSDiffuse ( int diffuse ) #
Console: render_sssss_diffuse
Enables or disables the SSSSS (Screen-Space Subsurface Scattering) calculation for diffuse lighting (directional lights).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int diffuse - 1 to enable the SSSSS calculation for diffuse lighting;0 — to disable it.
int engine.render.isSSSSSDiffuse ( ) #
Console: render_sssss_diffuse
Returns a value indicating if the SSSSS (Screen-Space Subsurface Scattering) calculation for diffuse lighting (directional lights) is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the SSSSS calculation for diffuse lighting is enabled; otherwise, 0.void engine.render.setSSSSSAmbient ( int ambient ) #
Console: render_sssss_ambient
Enables or disables the SSSSS (Screen-Space Subsurface Scattering) calculation for ambient lighting (environment).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int ambient - 1 to enable the SSSSS calculation for ambient lighting; 0 — to disable it.
int engine.render.isSSSSSAmbient ( ) #
Console: render_sssss_ambient
Returns a value indicating if the SSSSS (Screen-Space Subsurface Scattering) calculation for ambient lighting (environment) is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the SSSSS calculation for ambient lighting is enabled; otherwise, 0.void engine.render.setSSSSSMinThreshold ( float threshold ) #
Console: render_sssss_min_threshold
Sets the threshold of SSSSS (Screen-Space Subsurface Scattering) for the material's Translucent parameter equal to 0 (minimum translucency).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold scattering value for the material's Translucent parameter equal to 0.
float engine.render.getSSSSSMinThreshold ( ) #
Console: render_sssss_min_threshold
Returns the threshold of SSSSS (Screen-Space Subsurface Scattering) for the material's Translucent parameter equal to 0 (minimum translucency).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold scattering value for the material's Translucent parameter equal to 0.void engine.render.setSSSSSMaxThreshold ( float threshold ) #
Console: render_sssss_max_threshold
Sets the threshold of SSSSS (Screen-Space Subsurface Scattering) for the material's Translucent parameter equal to 1 (maximum translucency).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold scattering value for the material's Translucent parameter equal to 1.
float engine.render.getSSSSSMaxThreshold ( ) #
Console: render_sssss_max_threshold
Returns the threshold of SSSSS (Screen-Space Subsurface Scattering) for the material's Translucent parameter equal to 1 (maximum translucency).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold scattering value for the material's Translucent parameter equal to 1.void engine.render.setSSSSSNoiseStep ( float step ) #
Console: render_sssss_noise_step
Sets the intensity of the step noise used for SSSSS (Screen-Space Subsurface Scattering) calculation to reduce banding artifacts of tracing: higher values make banding less visible.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float step - Intensity of the step noise used for SSSSS calculation.
float engine.render.getSSSSSNoiseStep ( ) #
Console: render_sssss_noise_step
Returns the intensity of the step noise used for SSSSS (Screen-Space Subsurface Scattering) calculation to reduce banding artifacts of tracing: higher values make banding less visible.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Intensity of the step noise used for SSSSS calculation.void engine.render.setSSSSSNoiseRay ( float ray ) #
Console: render_sssss_noise_ray
Sets the intensity of the ray noise used for SSSSS (Screen-Space Subsurface Scattering) calculation to reduce banding artifacts of tracing: higher values make banding less visible.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float ray - Intensity of the ray noise used for SSSSS calculation.
float engine.render.getSSSSSNoiseRay ( ) #
Console: render_sssss_noise_ray
Returns the intensity of the ray noise used for SSSSS (Screen-Space Subsurface Scattering) calculation to reduce banding artifacts of tracing: higher values make banding less visible.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Intensity of the ray noise used for SSSSS calculation.void engine.render.setSSSSSInterleaved ( int interleaved ) #
Console: render_sssss_interleaved
Enables or disables interleaved rendering mode for SSSSS (Screen-Space Subsurface Scattering).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int interleaved - 1 to enable the interleaved mode for SSSSS; 0 — to disable it.
int engine.render.isSSSSSInterleaved ( ) #
Console: render_sssss_interleaved
Returns a value indicating if the interleaved rendering mode for SSSSS (Screen-Space Subsurface Scattering) is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the interleaved mode for SSSSS is enabled; otherwise, 0.void engine.render.setSSSSSInterleavedColorClamping ( int clamping ) #
Sets the color clamping mode used to reduce ghosting effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int clamping - One of the color clamping modes:
- 0 — disabled
- 1 — low
- 2 — medium
- 3 — high
- 4 — high + velocity
int engine.render.getSSSSSInterleavedColorClamping ( ) #
Returns the color clamping mode used to reduce ghosting effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
One of the color clamping modes:- 0 — disabled
- 1 — low
- 2 — medium
- 3 — high
- 4 — high + velocity
void engine.render.setSSSSSInterleavedSamples ( int samples ) #
Console: render_sssss_interleaved_samples
Defines the number of pixels to be skipped when rendering the SSSSS (Screen-Space Subsurface Scattering) effect with subsequent reconstruction of neighboring pixels using the data from previous frames.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int samples -
- 0 — half of all pixels is rendered skipping each second line (1 x 2)
- 1 — quarter of all pixels is rendered skipping each second line and row (2 x 2)
int engine.render.getSSSSSInterleavedSamples ( ) #
Console: render_sssss_interleaved_samples
Defines the number of pixels to be skipped when rendering the SSSSS (Screen-Space Subsurface Scattering) effect with subsequent reconstruction of neighboring pixels using the data from previous frames.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
- 0 — half of all pixels is rendered skipping each second line (1 x 2)
- 1 — quarter of all pixels is rendered skipping each second line and row (2 x 2)
void engine.render.setSSSSSTAAFixFlicker ( int flicker ) #
Console: render_sssss_taa_fix_flicker
Enables or disables the Fix Flicker effect for the SSSSS (Screen-Space Subsurface Scattering) effect that removes bright pixels by using the pixel brightness information from the previous frame.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int flicker - 1 to enable the Fix Flicker effect; 0 — to disable it.
int engine.render.isSSSSSTAAFixFlicker ( ) #
Console: render_sssss_taa_fix_flicker
Returns a value indicating if the Fix Flicker effect is enabled for the SSSSS (Screen-Space Subsurface Scattering) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the Fix Flicker effect is enabled; otherwise, 0.void engine.render.setSSSSSTAAAntialiasingInMotion ( int motion ) #
Enables or disables antialiasing in motion (for moving camera and objects) for the SSSSS (Screen-Space Subsurface Scattering) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int motion - 1 to enable antialiasing in motion; 0 — to disable it.
int engine.render.isSSSSSTAAAntialiasingInMotion ( ) #
Returns a value indicating if antialiasing in motion is enabled for the SSSSS (Screen-Space Subsurface Scattering) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if antialiasing in motion is enabled; otherwise, 0.void engine.render.setSSSSSTAAFramesByColor ( int color ) #
Console: render_sssss_taa_frames_by_color
Enables or disables the Frames By Color option for SSSSS allowing accumulation of a variable number of frames over time depending on the pixel color difference between the current and previous frames.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int color - 1 to enable the Frames By Color option; 0 — to disable it.
int engine.render.isSSSSSTAAFramesByColor ( ) #
Console: render_sssss_taa_frames_by_color
Returns a value indicating if the Frames By Color option for the SSSSS (Screen-Space Subsurface Scattering) effect is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the Frames By Color option is enabled; otherwise, 0.void engine.render.setSSSSSTAAFramesByVelocity ( int velocity ) #
Console: render_sssss_taa_frames_by_velocity
Enables or disables the Frames By Velocity option for the SSSSS (Screen-Space Subsurface Scattering) effect allowing accumulaton of a variable number of frames over time depending on the pixel velocity difference between the current and previous frames.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int velocity - 1 to enable the Frames By Velocity option; 0 — to disable it.
int engine.render.isSSSSSTAAFramesByVelocity ( ) #
Console: render_sssss_taa_frames_by_velocity
Returns a value indicating if the Frames By Velocity option for the SSSSS (Screen-Space Subsurface Scattering) effect is enabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
1 if the Frames By Velocity option is enabled; otherwise, 0.void engine.render.setSSSSSTAAPreserveDetails ( float details ) #
Console: render_sssss_taa_preserve_details
Enables or disables the Preserve Details option that controls the TAA (Temporal Anti-Aliasing) detail level for the SSSSS (Screen-Space Subsurface Scattering) effect: the higher the value, the more detailed the image is. At the value of 0, the image becomes blurred when moving the camera, however, the TAA effect is better.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float details - The TAA detail level.
float engine.render.getSSSSSTAAPreserveDetails ( ) #
Console: render_sssss_taa_preserve_details
Returns the value of the TAA (Temporal Anti-Aliasing) detail level for the SSSSS (Screen-Space Subsurface Scattering) effect: the higher the value, the more detailed the image is. At the value of 0, the image becomes blurred when moving the camera, however, the TAA effect is better.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
The TAA detail level.void engine.render.setSSSSSTAAFrameCount ( float count ) #
Console: render_sssss_taa_frame_count
Sets the number of frames that are combined and blended during TAA calculation for the SSSSS (Screen-Space Subsurface Scattering) effect. The higher the value, the more frames are combined into the final image and the better anti-aliasing is. This value is used only when Frames By Velocity option is disabled.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float count - The number of frames for velocity buffer. The default value is 30.0f
float engine.render.getSSSSSTAAFrameCount ( ) #
Console: render_sssss_taa_frame_count
Returns the number of frames that are combined and blended during TAA calculation for the SSSSS (Screen-Space Subsurface Scattering) effect. The higher the value, the more frames are combined into the final image and the better anti-aliasing is. This value is used only when Frames By Velocity option is disabled.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
The number of frames for velocity buffer. The default value is 30.0fvoid engine.render.setSSSSSTAAFramesVelocityThreshold ( float threshold ) #
Sets the threshold value defining sensitivity to velocity change (velocity threshold at which pixels are treated as fast moving) for the SSSSS (Screen-Space Subsurface Scattering) effect.Arguments
- float threshold - Velocity threshold at which pixels are treated as fast-moving.
float engine.render.getSSSSSTAAFramesVelocityThreshold ( ) #
Returns the threshold value defining sensitivity to velocity change (velocity threshold at which pixels are treated as fast moving) for the SSSSS (Screen-Space Subsurface Scattering) effect.Return value
Velocity threshold at which pixels are treated as fast-moving.void engine.render.setSSSSSTAAMaxFramesByVelocity ( float velocity ) #
Sets the number of frames combined and blended for pixels that don't move relative to the screen space — the maximum frame count of TAA (Temporal Anti-Aliasing) for the SSSSS (Screen-Space Subsurface Scattering) effect.Arguments
- float velocity - Maximum number of frames for velocity buffer. The default value is 60.0f.
float engine.render.getSSSSSTAAMaxFramesByVelocity ( ) #
Returns the number of frames combined and blended for pixels that don't move relative to the screen space — the maximum frame count of TAA (Temporal Anti-Aliasing) for the SSSSS (Screen-Space Subsurface Scattering) effect.Return value
Maximum number of frames for velocity buffer.void engine.render.setSSSSSTAAMinFramesByVelocity ( float velocity ) #
Sets the number of frames combined and blended for fast-moving pixels on the screen — the minimum frame count of TAA (Temporal Anti-Aliasing) for the SSSSS (Screen-Space Subsurface Scattering) effect.Arguments
- float velocity - Minimum number of frames for velocity buffer. The default value is 4.0f.
float engine.render.getSSSSSTAAMinFramesByVelocity ( ) #
Returns the number of frames combined and blended for fast-moving pixels on the screen — the minimum frame count of TAA (Temporal Anti-Aliasing) for the SSSSS (Screen-Space Subsurface Scattering) effect.Return value
Minimum number of frames for velocity buffer.void engine.render.setSSSSSTAACatmullResampling ( int resampling ) #
Console: render_sssss_taa_catmull_resampling
Enables and disables Catmull-Rom resampling for Screen-Space Subsurface Scattering. It allows reducing image blurring when the camera moves forward/backward. It is recommended to disable resampling at low settings.Arguments
- int resampling - 1 to enable Catmull-Rom resampling; 0 — to disable it.
int engine.render.isSSSSSTAACatmullResampling ( ) #
Console: render_sssss_taa_catmull_resampling
Returns a value indicating if Catmull-Rom resampling for Screen-Space Subsurface Scattering is enabled. It allows reducing image blurring when the camera moves forward/backward. It is recommended to disable resampling at low settings.Return value
1 if Catmull-Rom resampling is enabled; otherwise, 0.void engine.render.setSSSSSTAASamples ( int samples ) #
Console: render_sssss_taa_samples
Sets the number of the sample offsets performed during subpixel jittering for Screen-Space Subsurface Scattering. By the minimum value of 1, there will be no offsets, and, therefore, no anti-aliasing.Arguments
- int samples - One of the values defining the number of samples:
- 0 — 1 sample offset, no anti-aliasing
- 1 — 4 offsets
- 2 — 8 offsets
- 3 — 16 offsets
int engine.render.getSSSSSTAASamples ( ) #
Console: render_sssss_taa_samples
Returns the number of the sample offsets performed during subpixel jittering for Screen-Space Subsurface Scattering. By the minimum value of 1, there will be no offsets, and, therefore, no anti-aliasing.Return value
One of the values defining the number of samples:- 0 — 1 sample offset, no anti-aliasing
- 1 — 4 offsets
- 2 — 8 offsets
- 3 — 16 offsets
void engine.render.setEnvironmentCorrectRoughness ( int roughness ) #
Console: render_environment_correct_roughness
Enables one of correction modes for environment reflections on rough surfaces or disables correction. Correction modes differ in the number of rays used to create a reflection on a rough surface.Arguments
- int roughness - One of the RENDER_CORRECT_ROUGHNESS_* modes.
int engine.render.getEnvironmentCorrectRoughness ( ) #
Console: render_environment_correct_roughness
Returns the value indicating the correction mode set for environment reflections on rough surfaces. Correction modes differ in the number of rays used to create a reflection on a rough surface.Return value
One of the RENDER_CORRECT_ROUGHNESS_* modes.void engine.render.getScreenshot ( Image image ) #
Takes a screenshot and puts it to the specified image.Arguments
- Image image - Image to which the screenshot is to be saved.
void engine.render.setShowLandscapeAlbedo ( int albedo ) #
Console: render_show_landscape_albedo
Sets a value indicating if visualization of albedo data of the Landscape Terrain is enabled. This parameter is stored in the following configuration file: Arguments
- int albedo - 1 to enable visualization of albedo data of the Landscape Terrain; 0 — to disable it.
int engine.render.isShowLandscapeAlbedo ( ) #
Console: render_show_landscape_albedo
Returns a value indicating if visualization of albedo data of the Landscape Terrain is enabled. This parameter is stored in the following configuration file: Return value
1 if visualization of albedo data of the Landscape Terrain is enabled; otherwise, 0.void engine.render.setShowLandscapeMask ( int mask ) #
Console: render_show_landscape_mask
Sets the number of the landscape terrain detail mask to be visualized. This method can be used for visual debugging to display the selected detail mask of the landscape terrain. This parameter is stored in the following configuration file: Arguments
- int mask - Number of landscape terrain detail mask to be visualized in the [1; 20] range, or 0 - to disable mask visualization.
int engine.render.getShowLandscapeMask ( ) #
Console: render_show_landscape_mask
Returns the number of the landscape terrain detail mask currently visualized. This method can be used for visual debugging to display the selected detail mask of the landscape terrain. This parameter is stored in the following configuration file: Return value
Number of the currently visualized landscape terrain detail mask in the [1; 20] range, or 0 if mask visualization is disabled.void engine.render.setShowLandscapeTerrainVTStreaming ( int streaming ) #
Sets a value indicating if visualization is enabled for streaming of tiles of the landscape terrain megatexture. This method can be used for visual adjustment of the streaming process. This parameter is stored in the following configuration file:Arguments
- int streaming - 1 to enable visualization of streaming of landscape terrain tiles; 0 — to disable it.
int engine.render.isShowLandscapeTerrainVTStreaming ( ) #
Returns a value indicating if visualization is enabled for streaming of tiles of the landscape terrain megatexture. This method can be used for visual adjustment of the streaming process. This parameter is stored in the following configuration file:Return value
1 if visualization for streaming of tiles of the landscape terrain megatexture is enabled; otherwise, 0.void engine.render.setLandscapeTerrainVTMemorySize ( float size ) #
Sets a value defining memory consumption for the Landscape Terrain textures.Arguments
- float size - Memory consumption factor in the [0.0f; 1.0f] range:
- 0.0f corresponds to 3072 x 3072 (~200 MB of VRAM)
- 1.0f corresponds to 16384 x 16384 (~3.1 GB of VRAM)
float engine.render.getLandscapeTerrainVTMemorySize ( ) #
Returns a value defining memory consumption for the Landscape Terrain textures.Return value
Memory consumption factor in the [0.0f; 1.0f] range:- 0.0f corresponds to 3072 x 3072 (~200 MB of VRAM)
- 1.0f corresponds to 16384 x 16384 (~3.1 GB of VRAM)
void engine.render.setLandscapeTerrainVTTargetResolution ( vec2 resolution ) #
Sets the target resolution for the landscape terrain.Arguments
- vec2 resolution - Two-component vector defining the target viewport resolution along X and Y axes. The default value is 1344 x 756.
vec2 engine.render.getLandscapeTerrainVTTargetResolution ( ) #
Returns the current target resolution for the landscape terrain.Return value
Two-component vector defining the target viewport resolution along X and Y axes. The default value is 1344 x 756.void engine.render.setLandscapeTerrainVTDetailLevelByAngle ( float angle ) #
Sets a value indicating detail level reduction depending on the inclination of the the Landscape Terrain polygons relative to viewing direction. Can be used to reduce streaming load and memory consumption.Arguments
- float angle - Detail level quality value in the [0.0f; 1.0f] range:
- 1.0f - pixel-to-pixel quality
- lower values decrease quality
float engine.render.getLandscapeTerrainVTDetailLevelByAngle ( ) #
Returns a value indicating detail level reduction depending on the inclination of the the Landscape Terrain polygons relative to viewing direction. Can be used to reduce streaming load and memory consumption.Return value
Detail level quality value in the [0.0f; 1.0f] range:- 1.0f - pixel-to-pixel quality
- lower values decrease quality
void engine.render.setLandscapeTerrainVTFiltering ( int filtering ) #
Sets the filtering mode for the Landscape Terrain textures.Arguments
- int filtering - Filtering mode to be used:
- 0 — Low (lower mip-level is used)
- 1 — Medium (higher mip-level is used)
- 2 — High (linear interpolation between adjacent mip-levels)
int engine.render.getLandscapeTerrainVTFiltering ( ) #
Returns the filtering mode currently used for the Landscape Terrain textures.Return value
Filtering mode currently used:- 0 — Low (lower mip-level is used)
- 1 — Medium (higher mip-level is used)
- 2 — High (linear interpolation between adjacent mip-levels)
void engine.render.setLandscapeTerrainVTTilesUpdatePerFrame ( int frame ) #
Sets the number of tiles passed to the virtual texture of the Landscape Terrain each frame.Arguments
- int frame - Number of terrain tiles to be passed to the virtual texture each frame, in the [1; 256] range. The default value is 60.
int engine.render.getLandscapeTerrainVTTilesUpdatePerFrame ( ) #
Returns the current number of tiles passed to the virtual texture of the Landscape Terrain each frame.Return value
Number of tiles currently passed to the virtual texture each frame, in the [1; 256] range. The default value is 60.void engine.render.setLandscapeTerrainVTTilesLoadPerFrame ( int frame ) #
Sets the number of landscape terrain tiles to be loaded per frame. You can decrease the value of this parameter to reduce spikes, but in this case streaming becomes slower and more noticeable.Arguments
- int frame - Number of landscape terrain tiles to be loaded per frame, in the [1; 64] range. The default value is 4.
int engine.render.getLandscapeTerrainVTTilesLoadPerFrame ( ) #
Returns the current number of landscape terrain tiles loaded per frame. You can decrease the value of this parameter to reduce spikes, but in this case streaming becomes slower and more noticeable.Return value
Number of landscape terrain tiles currently loaded per frame, in the [1; 64] range. The default value is 4.void engine.render.setLandscapeTerrainVTTilesReloadPerFrame ( int frame ) #
Sets the number of tiles to be reloaded per frame after applying changes to the Landscape Terrain surface.Arguments
- int frame - Number of tiles to be reloaded per frame, in the [1; 64] range. The default value is 4.
int engine.render.getLandscapeTerrainVTTilesReloadPerFrame ( ) #
Returns the current number of tiles to be reloaded per frame after applying changes to the Landscape Terrain surface.Return value
Number of tiles to be reloaded per frame, in the [1; 64] range. The default value is 4.void engine.render.setLandscapeTerrainDetailResolutionAdditionalMask ( int mask ) #
Sets the resolution of the additional mask texture for details of the landscape terrain.Arguments
- int mask - Texture resolution to be set. One of the following values:
- 0 - 64×64
- 1 - 128×128
- 2 - 256×256
- 3 - 512×512
- 4 - 1024×1024 (default)
- 5 - 2048×2048
- 6 - 4096×4096
- 7 - 8192×8192
- 8 - 16384×16384
int engine.render.getLandscapeTerrainDetailResolutionAdditionalMask ( ) #
Returns the current resolution of the additional mask texture for details of the landscape terrain.Return value
Current texture resolution. One of the following values:- 0 - 64×64
- 1 - 128×128
- 2 - 256×256
- 3 - 512×512
- 4 - 1024×1024 (default)
- 5 - 2048×2048
- 6 - 4096×4096
- 7 - 8192×8192
- 8 - 16384×16384
void engine.render.setLandscapeTerrainDetailResolutionAlbedo ( int albedo ) #
Sets the resolution of the albedo texture for details of the landscape terrain.Arguments
- int albedo - Texture resolution to be set. One of the following values:
- 0 - 64×64
- 1 - 128×128
- 2 - 256×256
- 3 - 512×512
- 4 - 1024×1024 (default)
- 5 - 2048×2048
- 6 - 4096×4096
- 7 - 8192×8192
- 8 - 16384×16384
int engine.render.getLandscapeTerrainDetailResolutionAlbedo ( ) #
Returns the current resolution of the albedo texture for details of the landscape terrain.Return value
Current texture resolution. One of the following values:- 0 - 64×64
- 1 - 128×128
- 2 - 256×256
- 3 - 512×512
- 4 - 1024×1024 (default)
- 5 - 2048×2048
- 6 - 4096×4096
- 7 - 8192×8192
- 8 - 16384×16384
void engine.render.setLandscapeTerrainDetailResolutionHeight ( int height ) #
Sets the resolution of the height texture for details of the landscape terrain.Arguments
- int height - Texture resolution to be set. One of the following values:
- 0 - 64×64
- 1 - 128×128
- 2 - 256×256
- 3 - 512×512
- 4 - 1024×1024 (default)
- 5 - 2048×2048
- 6 - 4096×4096
- 7 - 8192×8192
- 8 - 16384×16384
int engine.render.getLandscapeTerrainDetailResolutionHeight ( ) #
Returns the current resolution of the height texture for details of the landscape terrain.Return value
Current texture resolution. One of the following values:- 0 - 64×64
- 1 - 128×128
- 2 - 256×256
- 3 - 512×512
- 4 - 1024×1024 (default)
- 5 - 2048×2048
- 6 - 4096×4096
- 7 - 8192×8192
- 8 - 16384×16384
void engine.render.setLandscapeTerrainMaskDithering ( float dithering ) #
Sets a new global dither amount multiplier to be used for rendering details of the landscape terrain. Dithering enables reduction of graphical artefacts in case of increased Mask Contrast values set for a detail. This is a global multiplier for dithering values set for each detail mask.Arguments
- float dithering - New global dither amount multiplier to be set in the [0.0f; 1.0f] range. The default value is 1.0f.
float engine.render.getLandscapeTerrainMaskDithering ( ) #
Returns the current global dither amount multiplier to be used for rendering details of the landscape terrain. Dithering enables reduction of graphical artefacts in case of increased Mask Contrast values set for a detail. This is a global multiplier for dithering values set for each detail mask.Return value
Current global dither amount multiplier in the [0.0f; 1.0f] range.void engine.render.setLandscapeTerrainVisibleDistance ( float distance ) #
Sets the maximum visibility distance for the landscape terrain. The terrain is visible, as long as the distance between the camera and the terrain does not exceed this value.Arguments
- float distance - Maximum visibility distance to be set for the landscape terrain, in meters. The default value is 30 km.
float engine.render.getLandscapeTerrainVisibleDistance ( ) #
Returns the current maximum visibility distance for the landscape terrain. The terrain is visible, as long as the distance between the camera and the terrain does not exceed this value.Return value
Maximum visibility distance for the landscape terrain, in meters. The default value is 30 km.void engine.render.setLandscapeTerrainGeometryHoles ( int holes ) #
Sets a value indicating if decal-based holes for the landscape terrain are enabled.Arguments
- int holes - 1 to enable decal-based holes for the landscape terrain; otherwise, 0.
int engine.render.isLandscapeTerrainGeometryHoles ( ) #
Returns a value indicating if decal-based holes for the landscape terrain are enabled.Return value
1 if decal-based holes are enabled for the landscape terrain; otherwise, 0.void engine.render.setLandscapeTerrainGeometryPolygonSize ( float size ) #
Sets the size of Landscape Terrain polygons defining the maximum allowed density of Landscape Terrain geometry.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float size - New size of Landscape Terrain polygons to be set (in units), in the [0.0001f, 1000.0f] range. The default value is 0.01f.
float engine.render.getLandscapeTerrainGeometryPolygonSize ( ) #
Returns the size of Landscape Terrain polygons defining the maximum allowed density of Landscape Terrain geometry.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current size of Landscape Terrain polygons (in units), in the [0.0001f, 1000.0f] range. The default value is 0.01f.void engine.render.setLandscapeTerrainGeometryProgression ( float progression ) #
Sets the progression of Landscape Terrain geometry tessellation.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float progression - New progression value to be set in the [0.0f; 50.0f] range. The default value is 1.5f.
float engine.render.getLandscapeTerrainGeometryProgression ( ) #
Returns the current progression of Landscape Terrain geometry tessellation.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current progression value in the [0.0f; 50.0f] range. The default value is 1.5f.void engine.render.setLandscapeTerrainGeometryFadeLods ( float lods ) #
Sets the intensity of fading between levels of Landscape Terrain geometry tessellation. This value can be increased to remove sharp edges between areas with different geometry density.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float lods - Fading intensity value to be set, in the [0.0f; 1.0f] range. The default value is 0.5f.
float engine.render.getLandscapeTerrainGeometryFadeLods ( ) #
Returns the current intensity of fading between levels of Landscape Terrain geometry tessellation. This value can be increased to remove sharp edges between areas with different geometry density.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current fading intensity value in the [0.0f; 1.0f] range. The default value is 0.5f.void engine.render.setLandscapeTerrainGeometrySubpixelReduction ( float reduction ) #
Sets the minimum ratio between the polygon size (in screen space) to the size of an area in the viewport for skipping polygons rendering (the ones having a lower ratio will be removed).Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float reduction - Subpixel reduction ratio to be set, in the [0.0f; 50.0f] range. The default value is 6.0f.
NoticeSetting too high values may cause small but noticeable visual artifacts when the camera moves.
float engine.render.getLandscapeTerrainGeometrySubpixelReduction ( ) #
Returns the minimum ratio between the polygon size (in screen space) to the size of an area in the viewport for skipping polygons rendering (the ones having a lower ratio will be removed).Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Current subpixel reduction ratio, in the [0.0f; 50.0f] range. The default value is 6.0f.void engine.render.setLandscapeTerrainCullingAggressive ( int aggressive ) #
Sets a value indicating if frustum culling optimization is enabled for the Landscape Terrain. When enabled, the number of culled polygons increases thereby increasing performance. In case of any issues with polygons rendering, try disabling this option (however, note that performance may drop).Arguments
- int aggressive - 1 to enable frustum culling optimization for the Landscape Terrain; 0 - to disable it.
int engine.render.isLandscapeTerrainCullingAggressive ( ) #
Returns a value indicating if frustum culling optimization is enabled for the Landscape Terrain. When enabled, the number of culled polygons increases thereby increasing performance. In case of any issues with polygons rendering, try disabling this option (however, note that performance may drop).Return value
1 if frustum culling optimization is enabled for the landscape terrain; otherwise, 0.void engine.render.setLandscapeTerrainCullingFrustumPadding ( float padding ) #
Sets a multiplier for the size of viewing frustum to be used for culling polygons of the Landscape Terrain.Arguments
- float padding - Frustumn padding multiplier to be set, in the [0.0f; 1.0f] range. The default value is 0.1f.
float engine.render.getLandscapeTerrainCullingFrustumPadding ( ) #
Returns the current multiplier for the size of viewing frustum used for culling polygons of the Landscape Terrain.Return value
Current frustumn padding multiplier, in the [0.0f; 1.0f] range. The default value is 0.1f.void engine.render.setLandscapeTerrainCullingBackFace ( float face ) #
Sets the threshold used for culling tessellation patches of the Landscape Terrain oriented to the camera with their back faces (it is a multiplier for the angle between the tessellation patch normal and the camera's view direction). Higher values result in a smaller angle between the patch normal and the camera's view direction required for culling this patch.Arguments
- float face - Backface culling threshold value to be set in the [0.0f; 1.0f] range. The default value is 0.5f.
float engine.render.getLandscapeTerrainCullingBackFace ( ) #
Returns the current threshold used for culling tessellation patches of the Landscape Terrain oriented to the camera with their back faces (it is a multiplier for the angle between the tessellation patch normal and the camera's view direction). Higher values result in a smaller angle between the patch normal and the camera's view direction required for culling this patch.Return value
Current backface culling threshold value in the [0.0f; 1.0f] range. The default value is 0.5f.void engine.render.setLandscapeTerrainCullingObliqueFrustum ( float frustum ) #
Sets the multiplier for culling of tessellation patches of the Landscape Terrain beyond the oblique frustum plane.Arguments
- float frustum - Multiplier value to be set, in the [0.0f, 1.0f] range. Higher values result in more patches culled. The default value is 0.9f.
float engine.render.getLandscapeTerrainCullingObliqueFrustum ( ) #
Returns the current multiplier for culling of tessellation patches of the Landscape Terrain beyond the oblique frustum plane.Return value
Current multiplier value, in the [0.0f, 1.0f] range. Higher values result in more patches culled. The default value is 0.9f.void engine.render.setLandscapeTerrainTexelSize ( float size ) #
Console: render_landscape_terrain_texel_size
Sets the texel size of the Landscape Terrain render textures representing the maximum level of detail for the albedo, normal, and height components of the Landscape Terrain.Arguments
- float size - Landscape Terrain texel size (in meters), in the [0.0001f, 1.0f] range. The default value is 0.001f.
float engine.render.getLandscapeTerrainTexelSize ( ) #
Console: render_landscape_terrain_texel_size
Returns the texel size of the Landscape Terrain render textures representing the maximum level of detail for the albedo, normal, and height components of the Landscape Terrain.Return value
Landscape Terrain texel size (in meters), in the [0.0001f, 1.0f] range. The default value is 0.001f.void engine.render.setLandscapeCacheCPUSize ( int size ) #
Console: render_landscape_cache_cpu_size
Sets the CPU cache size to be used for landscape terrain rendering. CPU cache size affects intersections, physics, streaming, etc. The size of CPU cache depends on the scene.Arguments
- int size - New СPU cache size to be set, in percentage of the total СPU memory. The default value is 10%.
int engine.render.getLandscapeCacheCPUSize ( ) #
Console: render_landscape_cache_cpu_size
Returns the current СPU cache size used for landscape terrain rendering. CPU cache size affects intersections, physics, streaming, etc. The size of CPU cache depends on the scene.Return value
Current CPU cache size, in percentage of the total GPU memory. The default value is 10%.void engine.render.setLandscapeCacheGPUSize ( int size ) #
Console: render_landscape_cache_gpu_size
Sets the GPU cache size to be used for landscape terrain rendering. GPU cache is used to accumulate tiles, that are visible to the camera, before streaming them to the megatexture.
Notice
High-resolution maps require larger cache capacity.
Arguments
- int size - New GPU cache size to be set, in percentage of the total GPU memory. The default value is 4%.
int engine.render.getLandscapeCacheGPUSize ( ) #
Console: render_landscape_cache_gpu_size
Returns the current GPU cache size used for landscape terrain rendering. GPU cache is used to accumulate tiles, that are visible to the camera, before streaming them to the megatexture.
Notice
High-resolution maps require larger cache capacity.
Return value
Current GPU cache size, in percentage of the total GPU memory. The default value is 4%.void engine.render.setLandscapeCacheGPULifeTime ( int time ) #
Console: render_landscape_cache_gpu_life_time
Sets the lifetime of GPU cache used for landscape terrain rendering.Arguments
- int time - New GPU cache lifetime to be set, number of frames in the [1; 60] range. The default value is 4.
int engine.render.getLandscapeCacheGPULifeTime ( ) #
Console: render_landscape_cache_gpu_life_time
Returns the current lifetime of GPU cache used for landscape terrain rendering.Return value
Current GPU cache lifetime, number of frames in the [1; 60] range. The default value is 4.void engine.render.setWireframeAntialiasing ( int antialiasing ) #
Console: render_wireframe_antialiasing
Sets a value indicating if antialiasing is enabled for wireframe rendering.Arguments
- int antialiasing - 1 to enable antialiasing for wireframe rendering; 0 - to disable it.
int engine.render.isWireframeAntialiasing ( ) #
Console: render_wireframe_antialiasing
Returns a value indicating if antialiasing is enabled for wireframe rendering.Return value
1 if antialiasing is enabled for wireframe rendering; otherwise, 0.void engine.render.setFfpAntialiasingLines ( int lines ) #
Console: render_ffp_antialiasing_lines
Sets a value indicating if antialiasing is enabled for rendering of the Visualizer and other FFP lines.Arguments
- int lines - 1 to enable antialiasing for visualizer rendering; 0 - to disable it.
int engine.render.isFfpAntialiasingLines ( ) #
Console: render_ffp_antialiasing_lines
Returns a value indicating if antialiasing is enabled for rendering of the Visualizer and other FFP lines.Return value
1 if antialiasing is enabled for rendering of the Visualizer and other FFP lines; otherwise, 0.int engine.render.isAPISupported ( int api ) #
Returns a value indicating if the specified graphics API (Null/OpenGL/DirectX) is currently supported.Arguments
- int api - Graphics API ID. One of the API_* values.
Return value
1 if the specified graphics API is currently supported; otherwise, 0.void engine.render.setCloudsRounded ( int rounded ) #
Console: render_clouds_rounded
Sets a value indicating if cloud layers are to be curved to make them look more natural imitating planet's curvature.Arguments
- int rounded - 1 to enable curving for clouds; 0 - to disable it.
int engine.render.isCloudsRounded ( ) #
Console: render_clouds_rounded
Returns a value indicating if cloud layers are to be curved to make them look more natural imitating planet's curvature.Return value
1 if visual curving for clouds is enabled; otherwise, 0.void engine.render.setCloudsRoundedPlanetRadius ( float radius ) #
Console: render_clouds_rounded_planet_radius
Sets the radius of the planet to be used for clouds curving. Visual curving can be used to make clouds look more natural imitating planet's curvature.Arguments
- float radius - Planet radius to be used for clouds curving, in units.
float engine.render.getCloudsRoundedPlanetRadius ( ) #
Console: render_clouds_rounded_planet_radius
Sets the radius of the planet to be used for clouds curving. Visual curving can be used to make clouds look more natural imitating planet's curvature.Return value
Planet radius used for clouds curving, in units.void engine.render.setPanoramaFisheyeFov ( float fov ) #
Console: render_panorama_fisheye_fov
Sets the Field of View in the Fisheye Panorama Custom mode.Arguments
- float fov - Field of View, in degrees.
float engine.render.getPanoramaFisheyeFov ( ) #
Console: render_panorama_fisheye_fov
Sets the Field of View in the Fisheye Panorama Custom mode.Return value
Field of View, in degrees.void engine.render.setSRAA ( int sraa ) #
Console: render_sraa
Toggles the SRAA on and off.Arguments
- int sraa - 1 to enable SRAA, 0 to disable it.
int engine.render.isSRAA ( ) #
Console: render_sraa
Returns a value indicating if SRAA is enabled.void engine.render.setSRAASamples ( int samples ) #
Console: render_sraa_samples
Sets the number of depth samples per pixel.Arguments
- int samples - The number of depth geometry samples per pixel. This value may significantly affect performance, so keep it low when the image quality differences are not apparent.
- 0 - 2 depth samples per pixel
- 1 - 4 depth samples per pixel
- 2 - 8 depth samples per pixel
int engine.render.getSRAASamples ( ) #
Console: render_sraa_samples
Returns the number of depth samples per pixel.void engine.render.setSRAATemporal ( int temporal ) #
Console: render_sraa_temporal
Toogles the usage of the shading sample from the previously rendered frame. Uses camera jittering, so it works only when the TAA is enabled.Arguments
- int temporal - 1 to enable TAA, 0 to disable it.
int engine.render.isSRAATemporal ( ) #
Console: render_sraa_temporal
Returns the value indicating if the TAA integration is enabled.void engine.render.setSRAADebug ( int debug ) #
Console: render_sraa_debug
Enables or disables the debug rendering of the smoothed geometry edges.Arguments
- int debug - 1 to enable debug mode, 0 to disable it.
int engine.render.isSRAADebug ( ) #
Console: render_sraa_debug
Returns the value indicating if the SRAA debug mode is enabled.void engine.render.setSRAADepthThreshold ( float threshold ) #
Console: render_sraa_depth_threshold
Sets the depth threshold value used for edges detection.Arguments
- float threshold - The depth threshold. Minimum value is 0.0f.
float engine.render.getSRAADepthThreshold ( ) #
Console: render_sraa_depth_threshold
Returns the depth threshold value used for edges detection.void engine.render.setSSGIIntensityBoost ( int boost ) #
Console: render_ssgi_intensity_boost
Sets the boost intensity value.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int boost - The value to which the intensity is raised. The set of accepted values: 1, 2, 3 and 4.
int engine.render.getSSGIIntensityBoost ( ) #
Console: render_ssgi_intensity_boost
Returns the intensity boost value.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
void engine.render.setTessellationDensityMultiplier ( float multiplier ) #
Sets the current global Density multiplier for the Tessellated Displacement effect.Arguments
- float multiplier - Tessellation Density multiplier in the [0.0f, 10.0f] range.
float engine.render.getTessellationDensityMultiplier ( ) #
Returns the current global Density multiplier for the Tessellated Displacement effect.Return value
Tessellation Density multiplier.void engine.render.setTessellationShadowDensityMultiplier ( float multiplier ) #
Sets the current global Shadow Density multiplier for the Tessellated Displacement effect.Arguments
- float multiplier - Tessellation Shadow Density multiplier in the [0.0f, 10.0f] range.
float engine.render.getTessellationShadowDensityMultiplier ( ) #
Returns the current global Shadow Density multiplier for the Tessellated Displacement effect.Return value
Tessellation Shadow Density multiplier.void engine.render.setTessellationDistanceMultiplier ( float multiplier ) #
Sets the current global multiplier for all distance parameters of the Tessellated Displacement effect.Arguments
- float multiplier - Tessellation distance multiplier in the [0.0f, 10.0f] range.
float engine.render.getTessellationDistanceMultiplier ( ) #
Returns the current global multiplier for all distance parameters of the Tessellated Displacement effect.Return value
Tessellation distance multiplier.void engine.render.setSSRNormalBias ( float bias ) #
Console: render_ssr_normal_bias
Sets the bias value for shifting of the ray starting position along the normal vector.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float bias - Normal bias value within the [0; 1] range.
float engine.render.getSSRNormalBias ( ) #
Console: render_ssr_normal_bias
Returns the bias value to which the ray starting position has been shifted along the normal vector.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Normal bias value within the [0; 1] range.void engine.render.setSSRViewBias ( float bias ) #
Console: render_ssr_view_bias
Sets the bias value for shifting of the ray starting position along the view vector.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float bias - View bias value within the [0; 1] range.
float engine.render.getSSRViewBias ( ) #
Console: render_ssr_view_bias
Returns the bias value to which the ray starting position has been shifted along the view vector.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
View bias value within the [0; 1] range.void engine.render.setLightmapColor ( vec4 color ) #
Console: render_lightmap_color
Returns the color multiplier for lightmaps. By default, the color is white.Arguments
- vec4 color - Color multiplier.
vec4 engine.render.getLightmapColor ( ) #
Console: render_lightmap_color
Returns the color multiplier for lightmaps.Return value
Color multiplier.void engine.render.setAAPreset ( int preset ) #
Sets the AA (Anti-Aliasing) preset as currently used.Arguments
- int preset - AA preset index.
int engine.render.getAAPreset ( ) #
Returns the index of a currently set AA (Anti-Aliasing) preset.Return value
AA preset index.int engine.render.getAAPresetNumNames ( ) #
Returns the number of AA (Anti-Aliasing) presets.string engine.render.getAAPresetName ( int num ) #
Returns the AA (Anti-Aliasing) preset name by given index.Arguments
- int num - AA preset index.
Return value
AA preset name.void engine.render.setTAAPreset ( int preset ) #
Sets the TAA (Temporal Anti-Aliasing) preset as currently used.Arguments
- int preset - TAA preset index.
int engine.render.getTAAPreset ( ) #
Returns the index of a currently set TAA (Temporal Anti-Aliasing) preset.Return value
TAA preset index.int engine.render.getTAAPresetNumNames ( ) #
Returns the number of TAA (Temporal Anti-Aliasing) presets.Return value
Quantity of TAA presets.string engine.render.getTAAPresetName ( int num ) #
Returns the TAA (Temporal Anti-Aliasing) preset name by given index.Arguments
- int num - TAA preset index.
Return value
TAA preset name.void engine.render.setRefractionWarpBackgroundTransparentSurfaces ( int sorting ) #
Arguments
- int sorting
int engine.render.getRefractionWarpBackgroundTransparentSurfaces ( ) #
void engine.render.setGIPreset ( int preset ) #
Sets the GI (Global Illumination) preset as currently used.Arguments
- int preset - GI preset index.
int engine.render.getGIPreset ( ) #
Returns the index of a currently set GI (Global Illumination) preset.Return value
GI preset index.int engine.render.getGIPresetNumNames ( ) #
Returns the number of GI (Global Illumination) presets.Return value
Quantity of GI presets.string engine.render.getGIPresetName ( int num ) #
Returns the GI (Global Illumination) preset name by given index.Arguments
- int num - GI preset index.
Return value
GI preset name.void engine.render.setSSRTGIPreset ( int preset ) #
Sets the SSRTGI (Screen-Space Ray-Traced Global Illumination) preset as currently used.Arguments
- int preset - SSRTGI preset index.
int engine.render.getSSRTGIPreset ( ) #
Returns the index of a currently set SSRTGI (Screen-Space Ray-Traced Global Illumination) preset.Return value
SSRTGI preset index.int engine.render.getSSRTGIPresetNumNames ( ) #
Returns the number of SSRTGI (Screen-Space Ray-Traced Global Illumination) presets.Return value
Quantity of SSRTGI presets.string engine.render.getSSRTGIPresetName ( int num ) #
Returns the SSRTGI (Screen-Space Ray-Traced Global Illumination) preset name by given index.Arguments
- int num - SSRTGI preset index.
Return value
SSRTGI preset name.void engine.render.setSSAOPreset ( int preset ) #
Sets the SSAO (Screen Space Ambient Occlusion) preset as currently used.Arguments
- int preset - SSAO preset index.
int engine.render.getSSAOPreset ( ) #
Returns the index of a currently set SSAO (Screen Space Ambient Occlusion) preset.Return value
SSAO preset index.int engine.render.getSSAOPresetNumNames ( ) #
Returns the number of SSAO (Screen Space Ambient Occlusion) presets.Return value
Quantity of SSAO presets.string engine.render.getSSAOPresetName ( int num ) #
Returns the SSAO (Screen Space Ambient Occlusion) preset name by given index.Arguments
- int num - SSAO preset index.
Return value
SSAO preset name.void engine.render.setSSAODenoiseIntensity ( float intensity ) #
Sets the noise reduction intensity for the SSAO (Screen Space Ambient Occlusion) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.
float engine.render.getSSAODenoiseIntensity ( ) #
Returns the current noise reduction intensity for the SSAO (Screen Space Ambient Occlusion) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.void engine.render.setSSAODenoiseGaussianSigma ( float sigma ) #
Sets the sigma parameter of Gaussian blur used for noise reduction for the SSAO (Screen Space Ambient Occlusion) effect. This parameter controls the amount of blur applied.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float sigma - Gaussian blur sigma parameter value in range [0.0f; 100.0f] to be set. The default value is 10.0f.
float engine.render.getSSAODenoiseGaussianSigma ( ) #
Returns the current value of the sigma parameter of Gaussian blur used for noise reduction for the SSAO (Screen Space Ambient Occlusion) effect. This parameter controls the amount of blur applied.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Gaussian blur sigma parameter value in range [0.0f; 100.0f] to be set. The default value is 10.0f.void engine.render.setSSAODenoiseThreshold ( float threshold ) #
Sets the threshold value for color difference of neighboring pixels used for noise reduction for the SSAO (Screen Space Ambient Occlusion) effect: blur is applied when the color difference is less than the threshold value.Notice
Setting too high values result in blurring the whole image.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f] to be set. The default value is 0.1f.
float engine.render.getSSAODenoiseThreshold ( ) #
Returns the current threshold value for color difference of neighboring pixels used for noise reduction for the SSAO (Screen Space Ambient Occlusion) effect: blur is applied when the color difference is less than the threshold value.Notice
Setting too high values result in blurring the whole image.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f] to be set. The default value is 0.1f.void engine.render.setSSAODenoiseRadius ( int radius ) #
Sets the radius of the area to be affected by noise reduction for the SSAO (Screen Space Ambient Occlusion) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int radius - Radius to be affected by noise reduction, an integer value in range [1; 3] to be set. The default value is 1.
int engine.render.getSSAODenoiseRadius ( ) #
Returns the current radius of the area to be affected by noise reduction for the SSAO (Screen Space Ambient Occlusion) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Radius to be affected by noise reduction, an integer value in range [1; 3] to be set. The default value is 1.void engine.render.setSSAOColorClampingIntensity ( float intensity ) #
Sets the intensity of TAA color clamping at zero pixel velocity for the SSAO (Screen Space Ambient Occlusion) effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSAO Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.
float engine.render.getSSAOColorClampingIntensity ( ) #
Returns the current intensity of TAA color clamping at zero pixel velocity for the SSAO (Screen Space Ambient Occlusion) effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use SSAO Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.void engine.render.setSSAOColorClampingVelocityThreshold ( float threshold ) #
Sets the sensitivity of TAA color clamping for the SSAO (Screen Space Ambient Occlusion) effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold for the intensity of TAA color clamping at zero pixel velocity.
float engine.render.getSSAOColorClampingVelocityThreshold ( ) #
Returns the current sensitivity of TAA color clamping for the SSAO (Screen Space Ambient Occlusion) effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold for the intensity of TAA color clamping at zero pixel velocity.void engine.render.setSSGIPreset ( int preset ) #
Sets the SSGI (Screen-Space Global Illumination) preset as currently used.Arguments
- int preset - SSGI preset index.
int engine.render.getSSGIPreset ( ) #
Returns the index of a currently set SSGI (Screen-Space Global Illumination) preset.Return value
SSGI preset index.int engine.render.getSSGIPresetNumNames ( ) #
Returns the number of SSGI (Screen-Space Global Illumination) presets.Return value
Quantity of SSGI presets.string engine.render.getSSGIPresetName ( int num ) #
Returns the SSGI (Screen-Space Global Illumination) preset name by given index.Arguments
- int num - SSGI preset index.
Return value
SSGI preset name.void engine.render.setBentNormalPreset ( int preset ) #
Sets the Bent Normal preset as currently used.Arguments
- int preset - Bent Normal preset index.
int engine.render.getBentNormalPreset ( ) #
Returns the index of a currently set Bent Normal preset.Return value
Bent Normal preset index.int engine.render.getBentNormalPresetNumNames ( ) #
Returns the number of Bent Normal presets.Return value
Quantity of Bent Normal presets.string engine.render.getBentNormalPresetName ( int num ) #
Returns the Bent Normal preset name by given index.Arguments
- int num - Bent Normal preset index.
Return value
Bent Normal preset name.void engine.render.setBentNormalDenoiseIntensity ( float intensity ) #
Sets the noise reduction intensity for the bent normals effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.
float engine.render.getBentNormalDenoiseIntensity ( ) #
Returns the current noise reduction intensity for the bent normals effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Noise reduction intensity value in range [0.0f; 1.0f] to be set. Higher values provide a less noisy, but more blurred result. The default value is 0.2f.void engine.render.setBentNormalDenoiseGaussianSigma ( float sigma ) #
Sets the sigma parameter of Gaussian blur used for noise reduction for the bent normals effect. This parameter controls the amount of blur applied.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float sigma - Gaussian blur sigma parameter value in range [0.0f; 100.0f] to be set. The default value is 10.0f.
float engine.render.getBentNormalDenoiseGaussianSigma ( ) #
Returns the current value of the sigma parameter of Gaussian blur used for noise reduction for the bent normals effect. This parameter controls the amount of blur applied.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Gaussian blur sigma parameter value in range [0.0f; 100.0f] to be set. The default value is 10.0f.void engine.render.setBentNormalDenoiseThreshold ( float threshold ) #
Sets the threshold value for color difference of neighboring pixels used for noise reduction for the bent normals effect: blur is applied when the color difference is less than the threshold value.Notice
Setting too high values result in blurring the whole image.
Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f]. The default value is 0.1f.
float engine.render.getBentNormalDenoiseThreshold ( ) #
Returns the current threshold value for color difference of neighboring pixels used for noise reduction for the bent normals effect: blur is applied when the color difference is less than the threshold value.Notice
Too high values result in blurring the whole image.
Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold value for color difference of neighboring pixels in range [0.0f; 1.0f]. The default value is 0.1f.void engine.render.setBentNormalDenoiseRadius ( int radius ) #
Sets the radius of the area to be affected by noise reduction for the bent normal effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- int radius - Radius to be affected by noise reduction, an integer value in range [1; 3] to be set. The default value is 1.
int engine.render.getBentNormalDenoiseRadius ( ) #
Returns the current radius of the area to be affected by noise reduction for the bent normal effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Radius to be affected by noise reduction, an integer value in range [1; 3]. The default value is 1.void engine.render.setBentNormalColorClampingIntensity ( float intensity ) #
Sets the intensity of TAA color clamping at zero pixel velocity for the bent normals effect.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float intensity - Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use Bent Normal Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.
float engine.render.getBentNormalColorClampingIntensity ( ) #
Returns the current intensity of TAA color clamping at zero pixel velocity for the bent normals effect.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Intensity of TAA color clamping at zero pixel velocity in range [0.0f; 1.0f]. Lower values result in more accumulated frames combined, which reduces noise flickering, but increases ghosting effect (to reduce ghosting in this case you can use Bent Normal Color Clamping Velocity Threshold), while higher values reduce ghosting effect, but increase flickering. The default value is 1.0f.void engine.render.setBentNormalColorClampingVelocityThreshold ( float threshold ) #
Sets the sensitivity of TAA color clamping for the bent normals effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
Setting the value via this method changes only the setting stored in the Custom preset, and will take an effect only when this preset is active.
Arguments
- float threshold - Threshold for the ray-traced bent normals calculation.
float engine.render.getBentNormalColorClampingVelocityThreshold ( ) #
Returns the current sensitivity of TAA color clamping for the bent normals effect to pixel velocity change. This parameter is used to reduce ghosting effect for lower Color Clamping Intensity values: it automatically increases clamping intensity for higher velocities, and disables clamping for low velocity values.Notice
When checking the parameter value via API you'll get the corresponding setting stored in the active preset (default or custom one).
Return value
Threshold for the ray-traced bent normals calculation.void engine.render.setSSRPreset ( int preset ) #
Sets the SSR preset as currently used.Arguments
- int preset - SSR preset index.
int engine.render.getSSRPreset ( ) #
Returns the index of a currently set SSR preset.Return value
SSR preset index.int engine.render.getSSRPresetNumNames ( ) #
Returns the number of SSR presets.Return value
Quantity of SSR presets.string engine.render.getSSRPresetName ( int num ) #
Returns the SSR preset name by given index.Arguments
- int num - SSR preset index.
Return value
SSR preset name.void engine.render.setSSSSSPreset ( int preset ) #
Sets the SSSSS preset as currently used.Arguments
- int preset - SSSSS preset index.
int engine.render.getSSSSSPreset ( ) #
Returns index of a currently set SSSSS preset.Return value
SSSSS preset index.int engine.render.getSSSSSPresetNumNames ( ) #
Returns the quantity of SSSSS presets.Return value
Quantity of SSSSS presets.string engine.render.getSSSSSPresetName ( int num ) #
Returns the SSSSS preset name by given index.Arguments
- int num - SSSSS preset index.
Return value
SSSSS preset name.void engine.render.setMotionBlurPreset ( int preset ) #
Sets the Motion Blur preset as currently used.Arguments
- int preset - Motion Blur preset index.
int engine.render.getMotionBlurPreset ( ) #
Returns the index of a currently set Motion Blur preset.Return value
Motion Blur preset index.int engine.render.getMotionBlurPresetNumNames ( ) #
Returns the quantity of Motion Blur presets.Return value
Quantity of Motion Blur presets.string engine.render.getMotionBlurPresetName ( int num ) #
Returns the Motion Blur preset name by given index.Arguments
- int num
Return value
Motion Blur preset name.void engine.render.setDOFPreset ( int preset ) #
Sets the DOF preset as currently used.Arguments
- int preset - Motion Blur preset index.
int engine.render.getDOFPreset ( ) #
Returns the index of a currently set DOF preset.Return value
Motion Blur preset index.int engine.render.getDOFPresetNumNames ( ) #
Returns the quantity of DOF presets.Return value
Quantity of DOF presets.string engine.render.getDOFPresetName ( int num ) #
Returns the DOF preset name by given index.Arguments
- int num
Return value
DOF preset name.void engine.render.setLandscapeTerrainGeometryPreset ( int preset ) #
Sets the Landscape Terrain Geometry preset as currently used.Arguments
- int preset - Landscape Terrain Geometry preset index.
int engine.render.getLandscapeTerrainGeometryPreset ( ) #
Returns the index of a currently set Landscape Terrain Geometry preset.Return value
Landscape Terrain Geometry preset index.int engine.render.getLandscapeTerrainGeometryPresetNumNames ( ) #
Returns the quantity of Landscape Terrain Geometry presets.Return value
Quantity of Landscape Terrain Geometry presets.string engine.render.getLandscapeTerrainGeometryPresetName ( int num ) #
Returns the Landscape Terrain Geometry preset name by given index.Arguments
- int num - Landscape Terrain Geometry preset index.
Return value
Landscape Terrain Geometry preset name.void engine.render.setLandscapeTerrainStreamingPreset ( int preset ) #
Sets the Landscape Terrain Streaming preset as currently used.Arguments
- int preset - Landscape Terrain Streaming preset index.
int engine.render.getLandscapeTerrainStreamingPreset ( ) #
Returns the index of a currently set Landscape Terrain Streaming preset.Return value
Landscape Terrain Streaming preset index.int engine.render.getLandscapeTerrainStreamingPresetNumNames ( ) #
Returns the quantity of Landscape Terrain Streaming presets.Return value
Quantity of Landscape Terrain Streaming presets.string engine.render.getLandscapeTerrainStreamingPresetName ( int num ) #
Returns the Landscape Terrain Streaming preset name by given index.Arguments
- int num - Landscape Terrain Streaming preset index.
Return value
Landscape Terrain Streaming preset name.void engine.render.setLandscapeOperationsPerFrame ( int frame ) #
Sets the number of Landscape texture draw operations (asyncTextureDraw) that can be performed per frame.Arguments
- int frame
int engine.render.getLandscapeOperationsPerFrame ( ) #
Returns the number of Landscape texture draw operations (asyncTextureDraw) that currently can be performed per frame.void engine.render.setShowLightmapChecker ( int checker ) #
Console: render_show_lightmap_checker
Enables the Baked Lightmap Checker debug mode. This mode maps the checker texture onto the baked lightmap polygons, which can be used to facilitate the process of comparing UV map texels on neighboring planes.Arguments
- int checker - 1, to enable the lightmap checker, 0 to disable it.
int engine.render.isShowLightmapChecker ( ) #
Console: render_show_lightmap_checker
Checks if the Baked Lightmap Checker debug mode is enabled. This mode maps the checker texture onto the baked lightmap polygons, which can be used to facilitate the process of comparing UV map texels on neighboring planes.Return value
1, if the lightmap checker is enabled, otherwise 0.void engine.render.setShowVoxelProbeVisualizer ( int visualizer ) #
Console: render_show_voxel_probe_visualizer
Sets a value indicating if the Voxel Probe visualizer is enabled. The visualizer shows only the selected probe with the grid size from 7 to 40.Arguments
- int visualizer - 1, to enable the visualizer for Voxel Probes, 0 to disable it.
int engine.render.isShowVoxelProbeVisualizer ( ) #
Console: render_show_voxel_probe_visualizer
Returns a value indicating if the Voxel Probe visualizer is enabled.Return value
1, if the visualizer for Voxel Probes is enabled, otherwise 0.void engine.render.setShowVoxelProbeVisualizerGridSize ( int size ) #
Sets the size of the grid that is used to visualize Voxel Probes.Notice
For the probe to be visualized properly, the grid size should be from 7 to 40.
Arguments
- int size - Number of spheres along the axis, the value from 7 to 40.
int engine.render.getShowVoxelProbeVisualizerGridSize ( ) #
Return the current size of the grid that is used to visualize Voxel Probes.Return value
Number of spheres along the axis, the value from 7 to 40.void engine.render.setShowVoxelProbeVisualizerSphereScale ( float scale ) #
Sets the scale factor of the sphere that is used to visualize Voxel Probes. The sphere size depends on the scale factor and the voxel size.Arguments
- float scale - Scale factor of the visualization sphere.
float engine.render.getShowVoxelProbeVisualizerSphereScale ( ) #
Returns the current scale factor of the sphere that is used to visualize the voxel probe. The sphere size depends on the scale factor and the voxel size.Return value
Scale factor of the visualization sphere.Last update:
2021-04-29
Help improve this article
Was this article helpful?
(or select a word/phrase and press Ctrl+Enter)