This test verifies that depth testing is enabled for the first
invocation of the vtkValuePass.

(cherry picked from commit a8551bd5)

Lucas Givord authored 5 months ago and Mathieu Westphal (Kitware) committed 4 months ago

(cherry picked from commit 7323f95c)

For some reason the baselines are slightly different on macos.

Sankhesh Jhaveri authored 9 months ago and Lucas Givord committed 7 months ago

(cherry picked from commit 3217a646)

- otherwise the shader could produce a different image from the baseline
  in case the timer fired before vtkWindowToImageFilter captured a screenshot
- make the test produce a deterministic image instead of using random
  noise function

- allows specification of custom uniforms on a vtkActor2D's shader property.
- this design follows the pattern from  the 3D vtkOpenGLPolyDataMapper.
- finally, ensure texture coordinates are available as inputs for vertex and
  fragment shaders so that shader developers can use that for any purpose besides
  texture mapping while customizing shader code.

Previous `TestMultiBlockPartialArrayFieldData` was leading to false positive tests by using different geometry
objects when no field data was attached. We update this test to use a `vtkCylinderSource` everywhere.
Also update other similar tests for consistency.

Michael Migliore authored 1 year ago and Lucas Givord committed 1 year ago

(cherry picked from commit 7f5417e5)

- these classes use texture buffers and vertex pulling which can help us reduce memory usage in the GLES 3.0 polydata mapper.

TestBlockOpacity is using vtkCompositePolyDataMapper2 that was deprecated
for 9.3.
Remove this test here as it won't pass after the fix introduced in
79969286.
Backporting 79969286 to fix the TestBlockOpacity is easy, but there is no
point in fixing the deprecated class. The functionality is still tested
with vtkCompositePolyDataMapper in Rendering/Core.

Most of these baselines are for text rendering, which often appears
different on different systems.

(cherry picked from commit a6137fa2)

(cherry picked from commit a6137fa2)

This reverts commit 911f2f99, reversing
changes made to f8463163.

- closes vtk/vtk#18664
- addresses async/paraview#118
- offscreen rendering does not invoke GUI functions
- add unit test to verify an offscreen render window
 from another thread is able to render safely

Update PBR shader in vtkOpenGLPolyDataMapperNode to simulate a clear
coat layer (upside layer on the material). This layer is supposed
dielectric and with low roughness, so it adds only a specular lobe to
the previous diffuse and specular parts of the base material.
The specular BRDF model of the coat layer is a Cook-Torrance specular
microfacet model,
with a GGX normal distribution function, a Smith visibility function,
and a Schlick
Fresnel function. Notice that it uses the exact same specular microfacet
model as the base layer specular BRDF.

It adds multiples parameters to vtkProperty :

* CoatStrength : [0-1], default to 0.0. Control the strength (0 means no layer)
* CoatRoughness : [0-1], default to 0.0. 0 means smooth layer (high specular
  reflection)
* CoatIOR : [0-4], default to 2.0. Define the material IOR of the layer.
* CoatColor : Default to white.
* CoatNormalScale : Scale the normal map (if present). Default is 1.0
* BaseIOR : the base material index of refraction, default to 1.5.
	When we add a coat layer, we need to recalculate the reflectance of the interface between
	the base material and the exterior, as the new exterior is now the coat
	layer. The precomputation of the reflecance is done in
	vtkOpenGLPolyDataMapperNode.

It is possible to define a normal map for the coat layer. If not
presents, we assume the layer has the same normal map as the base
material.

Since the logic for assign block properties was buggy and didn't handle
null blocks correctly, these baselines needed to be updated once the
logic was fixed.

Outline glow pass draws a glowing outline of a scene. Combined with layered
renderers this can be used to highlight parts of a scene. Outline glow uses
render passes to first draw the scene, apply gaussian blur and then draw the
blurred image only where no pixels were drawn in the original scene. The result
is an outline with a hard edge on the inside and a smooth edge on the outside.