-
Notifications
You must be signed in to change notification settings - Fork 1.2k
/
internal_render_engine_vtk.h
270 lines (220 loc) · 9.61 KB
/
internal_render_engine_vtk.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
#pragma once
#include <array>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <vtkActor.h>
#include <vtkAutoInit.h>
#include <vtkCommand.h>
#include <vtkImageExport.h>
#include <vtkLight.h>
#include <vtkNew.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkShaderProgram.h>
#include <vtkSmartPointer.h>
#include <vtkWindowToImageFilter.h>
#include "drake/common/drake_copyable.h"
#include "drake/geometry/render/render_engine.h"
#include "drake/geometry/render/render_label.h"
#include "drake/geometry/render/render_material.h"
#include "drake/geometry/render_vtk/render_engine_vtk_params.h"
#ifndef DRAKE_DOXYGEN_CXX
// This, and the ModuleInitVtkRenderingOpenGL2, provide the basis for enabling
// VTK's OpenGL2 infrastructure.
VTK_AUTOINIT_DECLARE(vtkRenderingOpenGL2)
#endif
namespace drake {
namespace geometry {
namespace render_vtk {
namespace internal {
#ifndef DRAKE_DOXYGEN_CXX
struct ModuleInitVtkRenderingOpenGL2 {
ModuleInitVtkRenderingOpenGL2(){
VTK_AUTOINIT_CONSTRUCT(vtkRenderingOpenGL2)
}
};
// A callback class for setting uniform variables used in shader programs,
// namely z_near and z_far, when vtkCommand::UpdateShaderEvent is caught.
// See also shaders::kDepthFS, this is where the variables are used.
// For the detail of VTK's callback mechanism, please refer to:
// https://www.vtk.org/doc/nightly/html/classvtkCommand.html#details
class ShaderCallback : public vtkCommand {
public:
DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(ShaderCallback);
ShaderCallback();
static ShaderCallback* New() { return new ShaderCallback; }
// NOLINTNEXTLINE(runtime/int): To match pre-existing APIs.
void Execute(vtkObject*, unsigned long, void* callback_object) override {
vtkShaderProgram* program =
reinterpret_cast<vtkShaderProgram*>(callback_object);
program->SetUniformf("z_near", z_near_);
program->SetUniformf("z_far", z_far_);
}
void set_z_near(float z_near) {
z_near_ = z_near;
}
void set_z_far(float z_far) {
z_far_ = z_far;
}
private:
float z_near_{0.f};
float z_far_{0.f};
};
// Not for external use, RenderEngineVtk uses this to index pipelines_ member.
// Do not change, remove, or add any values.
enum ImageType {
kColor = 0,
kLabel = 1,
kDepth = 2,
};
#endif // !DRAKE_DOXYGEN_CXX
/** See documentation of MakeRenderEngineVtk(). */
class RenderEngineVtk : public render::RenderEngine,
private ModuleInitVtkRenderingOpenGL2 {
public:
/** @name Does not allow copy, move, or assignment */
//@{
#ifdef DRAKE_DOXYGEN_CXX
// Note: the copy constructor operator is actually protected to serve as the
// basis for implementing the DoClone() method.
RenderEngineVtk(const RenderEngineVtk&) = delete;
#endif
RenderEngineVtk& operator=(const RenderEngineVtk&) = delete;
RenderEngineVtk(RenderEngineVtk&&) = delete;
RenderEngineVtk& operator=(RenderEngineVtk&&) = delete;
//@}}
/** Constructs the render engine from the given `parameters`.
When one of the optional parameters is omitted, the constructed value will be
as documented elsewhere in @ref render_engine_vtk_properties "this class".
*/
explicit RenderEngineVtk(
const RenderEngineVtkParams& parameters = RenderEngineVtkParams());
/** @see RenderEngine::UpdateViewpoint(). */
void UpdateViewpoint(const math::RigidTransformd& X_WR) override;
/** @name Shape reification */
//@{
using RenderEngine::ImplementGeometry;
void ImplementGeometry(const Box& box, void* user_data) override;
void ImplementGeometry(const Capsule& capsule, void* user_data) override;
void ImplementGeometry(const Convex& convex, void* user_data) override;
void ImplementGeometry(const Cylinder& cylinder, void* user_data) override;
void ImplementGeometry(const Ellipsoid& ellipsoid, void* user_data) override;
void ImplementGeometry(const HalfSpace& half_space, void* user_data) override;
void ImplementGeometry(const Mesh& mesh, void* user_data) override;
void ImplementGeometry(const Sphere& sphere, void* user_data) override;
//@}
/** @name Access the default properties
Provides access to the default values this instance of the render engine is
using. These values must be set at construction. */
//@{
Eigen::Vector4d default_diffuse() const {
return default_diffuse_.rgba();
}
using render::RenderEngine::default_render_label;
//@}
protected:
/** Returns all actors registered with the engine, keyed by the SceneGraph
GeometryId. Each GeometryId maps to a triple of actors: color, depth, and
label. */
const std::unordered_map<GeometryId,
std::array<vtkSmartPointer<vtkActor>, 3>>&
actors() const {
return actors_;
}
/** Copy constructor for the purpose of cloning. */
RenderEngineVtk(const RenderEngineVtk& other);
/** The rendering pipeline for a single image type (color, depth, or label).
*/
struct RenderingPipeline {
vtkNew<vtkRenderer> renderer;
vtkNew<vtkRenderWindow> window;
vtkNew<vtkWindowToImageFilter> filter;
vtkNew<vtkImageExport> exporter;
};
/** Configures the VTK model to reflect the given `camera`, this includes
render size camera intrinsics, visible windows, etc. If `show_window` is set
to true, a named VTK window will be displayed. */
void UpdateWindow(const render::RenderCameraCore& camera, bool show_window,
const RenderingPipeline& p, const char* name) const;
/** Variant of configuring the VTK model (see previous function) that *also*
configures the depth range. */
void UpdateWindow(const render::DepthRenderCamera& camera,
const RenderingPipeline& p) const;
/** Updates VTK rendering related objects including vtkRenderWindow,
vtkWindowToImageFilter and vtkImageExporter, so that VTK reflects
vtkActors' pose update for rendering. */
static void PerformVtkUpdate(const RenderingPipeline& p);
/** Provides access to the private data member pipelines_ by returning a
mutable RenderingPipeline reference. Only image types in ImageType enum are
valid. */
RenderingPipeline& get_mutable_pipeline(ImageType image_type) const;
private:
// @see RenderEngine::DoRegisterVisual().
bool DoRegisterVisual(GeometryId id, const Shape& shape,
const PerceptionProperties& properties,
const math::RigidTransformd& X_WG) override;
// @see RenderEngine::DoUpdateVisualPose().
void DoUpdateVisualPose(GeometryId id,
const math::RigidTransformd& X_WG) override;
// @see RenderEngine::DoRemoveGeometry().
bool DoRemoveGeometry(GeometryId id) override;
// @see RenderEngine::DoClone().
std::unique_ptr<RenderEngine> DoClone() const override;
// @see RenderEngine::DoRenderColorImage().
void DoRenderColorImage(
const render::ColorRenderCamera& camera,
systems::sensors::ImageRgba8U* color_image_out) const override;
// @see RenderEngine::DoRenderDepthImage().
void DoRenderDepthImage(
const render::DepthRenderCamera& render_camera,
systems::sensors::ImageDepth32F* depth_image_out) const override;
// @see RenderEngine::DoRenderLabelImage().
void DoRenderLabelImage(
const render::ColorRenderCamera& camera,
systems::sensors::ImageLabel16I* label_image_out) const override;
// Initializes the VTK pipelines.
void InitializePipelines();
// Common interface for loading an obj file -- used for both mesh and convex
// shapes.
void ImplementObj(const std::string& file_name, double scale,
void* user_data);
// Performs the common setup for all shape types.
void ImplementGeometry(vtkPolyDataAlgorithm* source,
const geometry::internal::RenderMaterial& material,
void* user_data);
void SetDefaultLightPosition(const Vector3<double>& X_DL) override;
// Three pipelines: rgb, depth, and label.
static constexpr int kNumPipelines = 3;
std::array<std::unique_ptr<RenderingPipeline>, kNumPipelines> pipelines_;
vtkNew<vtkLight> light_;
// By design, all of the geometry is shared across clones of the render
// engine. This is predicated upon the idea that the geometry is *not*
// deformable and does *not* depend on the system's pose information.
// (If there is deformable geometry, it will have to be handled differently.)
// Having "shared geometry" means having shared vtkPolyDataAlgorithm and
// vtkOpenGLPolyDataMapper instances. The shader callback gets registered to
// the *mapper* instances, so they all, implicitly, share the same callback.
// Making this member static facilitates that but it does preclude the
// possibility of simultaneous renderings with different uniform parameters.
// Currently, this doesn't happen because drake isn't particularly thread safe
// (or executed in such a context). However, this renderer will need some
// formal thread safe mechanism so that it doesn't rely on that in the future.
// TODO(SeanCurtis-TRI): This is not threadsafe; investigate mechanisms to
// prevent undesirable behaviors if used in multi-threaded application.
static vtkNew<ShaderCallback> uniform_setting_callback_;
// Obnoxious bright orange.
Rgba default_diffuse_{0.9, 0.45, 0.1, 1.0};
// The color to clear the color buffer to.
systems::sensors::ColorD default_clear_color_;
// The collection of per-geometry actors (one actor per pipeline (color,
// depth, and label) keyed by the geometry's GeometryId.
std::unordered_map<GeometryId, std::array<vtkSmartPointer<vtkActor>, 3>>
actors_;
};
} // namespace internal
} // namespace render_vtk
} // namespace geometry
} // namespace drake