Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
rs_processing_gl.hpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2017 Intel Corporation. All Rights Reserved.
3 
4 #ifndef LIBREALSENSE_RS2_PROCESSING_GL_HPP
5 #define LIBREALSENSE_RS2_PROCESSING_GL_HPP
6 
7 #include <librealsense2/rs.hpp>
8 #include "rs_processing_gl.h"
9 
10 #include <memory>
11 
12 namespace rs2
13 {
14  namespace gl
15  {
16  class pointcloud;
17  class yuy_to_rgb;
18 
19  inline void shutdown_rendering()
20  {
21  rs2_error* e = nullptr;
23  error::handle(e);
24  }
25 
26 #ifdef _glfw3_h_
27  inline void init_rendering(bool use_glsl = true)
28  {
29  rs2_error* e = nullptr;
30 
31  glfw_binding binding{
32  nullptr,
33  &glfwWindowHint,
34  &glfwCreateWindow,
35  &glfwDestroyWindow,
36  &glfwMakeContextCurrent,
37  &glfwGetCurrentContext,
38  &glfwSwapInterval,
39  &glfwGetProcAddress
40  };
41 
42  rs2_gl_init_rendering_glfw(RS2_API_VERSION, binding, use_glsl ? 1 : 0, &e);
43  error::handle(e);
44  }
45 #else
46  inline void init_rendering(bool use_glsl = true)
47  {
48  rs2_error* e = nullptr;
49  rs2_gl_init_rendering(RS2_API_VERSION, use_glsl ? 1 : 0, &e);
50  error::handle(e);
51  }
52 #endif
53 
54  inline void init_processing(bool use_glsl = true)
55  {
56  rs2_error* e = nullptr;
57  rs2_gl_init_processing(RS2_API_VERSION, use_glsl ? 1 : 0, &e);
58  error::handle(e);
59  }
60 
61  inline void shutdown_processing()
62  {
63  rs2_error* e = nullptr;
65  error::handle(e);
66  }
67 
68 #ifdef _glfw3_h_
69  inline void init_processing(GLFWwindow* share_with, bool use_glsl = true)
70  {
71  rs2_error* e = nullptr;
72 
73  glfw_binding binding{
74  nullptr,
75  &glfwWindowHint,
76  &glfwCreateWindow,
77  &glfwDestroyWindow,
78  &glfwMakeContextCurrent,
79  &glfwGetCurrentContext,
80  &glfwSwapInterval,
81  &glfwGetProcAddress
82  };
83 
84  rs2_gl_init_processing_glfw(RS2_API_VERSION, share_with, binding, use_glsl ? 1 : 0, &e);
85  error::handle(e);
86  }
87 #endif
88 
93  class gpu_frame : public frame
94  {
95  public:
96  gpu_frame(const frame& f)
97  : frame(f)
98  {
99  rs2_error* e = nullptr;
100  if (!f || (rs2_gl_is_frame_extendable_to(f.get(), RS2_GL_EXTENSION_VIDEO_FRAME, &e) == 0 && !e))
101  {
102  reset();
103  }
104  error::handle(e);
105  }
106 
107  uint32_t get_texture_id(unsigned int id = 0) const
108  {
109  rs2_error * e = nullptr;
110  auto r = rs2_gl_frame_get_texture_id(get(), id, &e);
111  error::handle(e);
112  return r;
113  }
114  };
115 
121  {
122  public:
123  yuy_decoder() : rs2::yuy_decoder(init()) { }
124 
125  private:
126  std::shared_ptr<rs2_processing_block> init()
127  {
128  rs2_error* e = nullptr;
129  auto block = std::shared_ptr<rs2_processing_block>(
132  error::handle(e);
133 
134  // Redirect options API to the processing block
135  //options::operator=(pb);
136 
137  return block;
138  }
139  };
140 
145  class colorizer : public rs2::colorizer
146  {
147  public:
148  colorizer() : rs2::colorizer(init()) { }
149 
150  private:
151  std::shared_ptr<rs2_processing_block> init()
152  {
153  rs2_error* e = nullptr;
154  auto block = std::shared_ptr<rs2_processing_block>(
157  error::handle(e);
158 
159  return block;
160  }
161  };
162 
163  class uploader : public rs2::filter
164  {
165  public:
166  uploader() : rs2::filter(init()) { }
167 
168  private:
169  std::shared_ptr<rs2_processing_block> init()
170  {
171  rs2_error* e = nullptr;
172  auto block = std::shared_ptr<rs2_processing_block>(
175  error::handle(e);
176  return block;
177  }
178  };
179 
185  {
186  public:
187  pointcloud() : rs2::pointcloud(init()) {}
188 
189  pointcloud(rs2_stream stream, int index = 0)
190  : rs2::pointcloud(init())
191  {
192  set_option(RS2_OPTION_STREAM_FILTER, float(stream));
194  }
195 
196  private:
197  friend class context;
198 
199  std::shared_ptr<rs2_processing_block> init()
200  {
201  rs2_error* e = nullptr;
202 
203  auto block = std::shared_ptr<rs2_processing_block>(
206 
207  error::handle(e);
208 
209  return block;
210  }
211  };
212 
219  {
220  public:
221  camera_renderer() : rs2::filter(init()) {}
222 
223  void set_matrix(rs2_gl_matrix_type type, float* m4x4)
224  {
225  rs2_error* e = nullptr;
226  rs2_gl_set_matrix(get(), type, m4x4, &e);
227  error::handle(e);
228  }
229 
230  private:
231  friend class context;
232 
233  std::shared_ptr<rs2_processing_block> init()
234  {
235  rs2_error* e = nullptr;
236 
237  auto block = std::shared_ptr<rs2_processing_block>(
240 
241  error::handle(e);
242  return block;
243  }
244  };
245 
253  {
254  public:
256 
257  void set_matrix(rs2_gl_matrix_type type, float* m4x4)
258  {
259  rs2_error* e = nullptr;
260  rs2_gl_set_matrix(get(), type, m4x4, &e);
261  error::handle(e);
262  }
263 
264  static const auto OPTION_FILLED = rs2_option(RS2_OPTION_COUNT + 1);
265  private:
266  friend class context;
267 
268  std::shared_ptr<rs2_processing_block> init()
269  {
270  rs2_error* e = nullptr;
271 
272  auto block = std::shared_ptr<rs2_processing_block>(
275 
276  error::handle(e);
277  return block;
278  }
279  };
280 
283  class align : public rs2::align
284  {
285  public:
286  align(rs2_stream to) : rs2::align(init(to)) {}
287 
288  private:
289  friend class context;
290 
291  std::shared_ptr<rs2_processing_block> init(rs2_stream to)
292  {
293  rs2_error* e = nullptr;
294 
295  auto block = std::shared_ptr<rs2_processing_block>(
298 
299  error::handle(e);
300 
301  return block;
302  }
303  };
304  }
305 }
306 #endif // LIBREALSENSE_RS2_PROCESSING_GL_HPP
void init_processing(bool use_glsl=true)
Definition: rs_processing_gl.hpp:54
Definition: rs_option.h:95
rs2_processing_block * rs2_gl_create_colorizer(int api_version, rs2_error **error)
void rs2_gl_shutdown_processing(int api_version, rs2_error **error)
Definition: rs_frame.hpp:336
#define RS2_API_VERSION
Definition: rs.h:41
Definition: rs_processing_gl.hpp:120
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls,...
Definition: rs_option.h:22
void rs2_gl_init_rendering_glfw(int api_version, glfw_binding bindings, int use_glsl, rs2_error **error)
Definition: rs_processing.hpp:482
Definition: rs_processing_gl.hpp:283
rs2_processing_block * rs2_gl_create_pointcloud_renderer(int api_version, rs2_error **error)
pointcloud(rs2_stream stream, int index=0)
Definition: rs_processing_gl.hpp:189
void rs2_gl_shutdown_rendering(int api_version, rs2_error **error)
Definition: rs_processing_gl.h:58
Definition: rs_context.hpp:11
int rs2_gl_is_frame_extendable_to(const rs2_frame *f, rs2_gl_extension extension_type, rs2_error **error)
gpu_frame(const frame &f)
Definition: rs_processing_gl.hpp:96
rs2_processing_block * rs2_gl_create_yuy_decoder(int api_version, rs2_error **error)
void shutdown_processing()
Definition: rs_processing_gl.hpp:61
Definition: rs_context.hpp:96
Definition: rs_processing_gl.hpp:184
void reset()
Definition: rs_frame.hpp:604
void set_matrix(rs2_gl_matrix_type type, float *m4x4)
Definition: rs_processing_gl.hpp:223
Definition: rs_processing_gl.hpp:145
Definition: rs_processing_gl.hpp:93
Exposes RealSense processing-block functionality for GPU for C compilers.
void rs2_gl_set_matrix(rs2_processing_block *block, rs2_gl_matrix_type type, float *m4x4, rs2_error **error)
void set_matrix(rs2_gl_matrix_type type, float *m4x4)
Definition: rs_processing_gl.hpp:257
uploader()
Definition: rs_processing_gl.hpp:166
pointcloud()
Definition: rs_processing_gl.hpp:187
void shutdown_rendering()
Definition: rs_processing_gl.hpp:19
align(rs2_stream to)
Definition: rs_processing_gl.hpp:286
Definition: rs_processing_gl.hpp:163
static const auto OPTION_FILLED
Definition: rs_processing_gl.hpp:264
void rs2_delete_processing_block(rs2_processing_block *block)
Definition: rs_processing.hpp:412
uint32_t get_texture_id(unsigned int id=0) const
Definition: rs_processing_gl.hpp:107
pointcloud_renderer()
Definition: rs_processing_gl.hpp:255
Definition: rs_processing_gl.h:24
void init_rendering(bool use_glsl=true)
Definition: rs_processing_gl.hpp:46
static void handle(rs2_error *e)
Definition: rs_types.hpp:130
rs2_stream
Streams are different types of data provided by RealSense devices.
Definition: rs_sensor.h:41
Definition: rs_processing.hpp:343
void rs2_gl_init_processing_glfw(int api_version, GLFWwindow *share_with, glfw_binding bindings, int use_glsl, rs2_error **error)
Definition: rs_option.h:69
Definition: rs_processing.hpp:708
rs2_processing_block * rs2_gl_create_camera_renderer(int api_version, rs2_error **error)
void rs2_gl_init_rendering(int api_version, int use_glsl, rs2_error **error)
Definition: rs_processing.hpp:664
rs2_processing_block * rs2_gl_create_uploader(int api_version, rs2_error **error)
void set_option(rs2_option option, float value) const
Definition: rs_options.hpp:99
yuy_decoder()
Definition: rs_processing_gl.hpp:123
rs2_processing_block * rs2_gl_create_align(int api_version, rs2_stream to, rs2_error **error)
rs2_gl_matrix_type
Definition: rs_processing_gl.h:33
rs2_processing_block * get() const
Definition: rs_processing.hpp:388
colorizer()
Definition: rs_processing_gl.hpp:148
Definition: rs_processing_gl.hpp:218
unsigned int rs2_gl_frame_get_texture_id(const rs2_frame *f, unsigned int id, rs2_error **error)
struct rs2_error rs2_error
Definition: rs_types.h:217
Definition: rs_processing_gl.hpp:252
rs2_processing_block * rs2_gl_create_pointcloud(int api_version, rs2_error **error)
rs2_frame * get() const
Definition: rs_frame.hpp:583
camera_renderer()
Definition: rs_processing_gl.hpp:221
struct GLFWwindow GLFWwindow
Definition: rs_processing_gl.h:43
void rs2_gl_init_processing(int api_version, int use_glsl, rs2_error **error)
Definition: rs_option.h:67