MeshLib C++ Docs
Loading...
Searching...
No Matches
MRViewport.h
Go to the documentation of this file.
1#pragma once
2
3#include "MRViewportGL.h"
4#include "MRFitData.h"
6#include <MRMesh/MRVector3.h>
7#include <MRMesh/MRPlane3.h>
10#include <MRMesh/MRQuaternion.h>
11#include <MRMesh/MRMatrix4.h>
12#include <MRMesh/MRColor.h>
13#include <MRMesh/MRBox.h>
14#include "MRImGui.h"
15#include <memory>
16#include <functional>
17#include <unordered_map>
18#include <optional>
19#include <span>
20
21namespace MR
22{
23
24inline ImVec2 position( const ViewportRectangle& rect )
25{
26 return { rect.min.x, rect.min.y };
27}
28
29inline ImVec2 size( const ViewportRectangle& rect )
30{
31 return { width( rect ), height( rect ) };
32}
33
34// Conversion to Vector4 type, where:
35// x, y: min.x and min.y
36// z, w: width and height
37template<typename T>
38inline Vector4<T> toVec4( const ViewportRectangle& rect )
39{
40 return Vector4<T>{T( rect.min.x ), T( rect.min.y ), T( MR::width( rect ) ), T( MR::height( rect ) )};
41}
42
43// Viewport is a rectangular area, in which the objects of interest are going to be rendered.
44// An application can have a number of viewports each with its own ID.
46{
47public:
49
52 MRVIEWER_API static Viewport& get( ViewportId viewportId = {} );
53
54 MRVIEWER_API Viewport();
55 MRVIEWER_API ~Viewport();
56
57private: //hide copying from the user to avoid silly mistakes (copies are necessary only inside this project)
58 Viewport( const Viewport & ) = default;
59 Viewport & operator = ( const Viewport & ) = default;
60public:
61 [[nodiscard]] Viewport clone() const { return Viewport( *this ); }
62 Viewport( Viewport && ) noexcept = default;
63 Viewport & operator = ( Viewport && ) noexcept = default;
64
65 // Initialization
66 MRVIEWER_API void init();
67
68 // positive pixelXoffset -> offset from the left border
69 // negative pixelXoffset -> offset from the right border
70 // positive pixelYoffset -> offset from the top border
71 // negative pixelYoffset -> offset from the bottom border
72 // axisPixSize -> length of each axes arrows in pixels
73 // For example: default values -> right bottom corner with 100 offsets for the base point and 80 pixels each axis length
74 MRVIEWER_API void setAxesPos( const int pixelXoffset = -100, const int pixelYoffset = -100 );
75 MRVIEWER_API void setAxesSize( const int axisPixSize = 80 );
76
78 MRVIEWER_API const Vector2f& getAxesPosition() const;
79 MRVIEWER_API float getAxesSize() const;
80
82 const Matrix4f& getAxesProjectionMatrix() const { return axesProjMat_; }
83
84 // Shutdown
85 MRVIEWER_API void shut();
86
87 // ------------------- Drawing functions
88
89 // Clear the frame buffers
90 MRVIEWER_API void clearFramebuffers();
91
94 MRVIEWER_API bool draw( const VisualObject& obj,
95 DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, bool allowAlphaSort = false ) const;
96
99 MRVIEWER_API bool draw( const VisualObject& obj, const AffineXf3f& xf,
100 DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, bool allowAlphaSort = false ) const;
101
104 MRVIEWER_API bool draw( const VisualObject& obj, const AffineXf3f& xf, const Matrix4f & projM,
105 DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, bool allowAlphaSort = false ) const;
106
109 {
110 float width{1.0f};
111 bool depthTest{ true };
112 };
113
115 MRVIEWER_API void drawLines( const std::vector<LineSegm3f>& lines, const std::vector<SegmEndColors>& colors, const LinePointImmediateRenderParams & params );
116 void drawLines( const std::vector<LineSegm3f>& lines, const std::vector<SegmEndColors>& colors, float width = 1, bool depthTest = true )
117 { drawLines( lines, colors, { getBaseRenderParams(), width, depthTest } ); }
118
120 MRVIEWER_API void drawPoints( const std::vector<Vector3f>& points, const std::vector<Vector4f>& colors, const LinePointImmediateRenderParams & params );
121 void drawPoints( const std::vector<Vector3f>& points, const std::vector<Vector4f>& colors, float width = 1, bool depthTest = true )
122 { drawPoints( points, colors, { getBaseRenderParams(), width, depthTest } ); }
123
125 {
126 Vector4f a, b, c;
127 };
128
130 MRVIEWER_API void drawTris( const std::vector<Triangle3f>& tris, const std::vector<TriCornerColors>& colors, const ModelRenderParams& params, bool depthTest = true );
131 MRVIEWER_API void drawTris( const std::vector<Triangle3f>& tris, const std::vector<TriCornerColors>& colors, const Matrix4f& modelM = {}, bool depthTest = true );
132
134 [[nodiscard]] BaseRenderParams getBaseRenderParams() const { return getBaseRenderParams( projM_ ); }
135
137 [[nodiscard]] BaseRenderParams getBaseRenderParams( const Matrix4f & projM ) const
138 { return { viewM_, projM, id, toVec4<int>( viewportRect_ ) }; }
139
142 const Matrix4f & modelM,
143 Matrix4f * normM,
146 bool allowAlphaSort = false
147 ) const
148 { return getModelRenderParams( modelM, projM_, normM, depthFunc, pass, allowAlphaSort ); }
149
151 [[nodiscard]] MRVIEWER_API ModelRenderParams getModelRenderParams( const Matrix4f & modelM, const Matrix4f & projM,
152 Matrix4f * normM,
155 bool allowAlphaSort = false
156 ) const;
157
158 // Predicate to additionally filter objects that should be treated as pickable.
159 using PickRenderObjectPredicate = std::function<bool ( const VisualObject*, ViewportMask )>;
160 // Point picking parameters.
162 {
163 // If specified, this is the target screen point. Otherwise use the mouse pos in viewport coordinates.
164 std::optional<Vector2f> point;
165
166 // Predicate to additionally filter objects that should be treated as pickable.
168
169 // Radius (in pixels) of a picking area.
170 // <0 defaults to `getViewerInstance().glPickRadius`.
171 int pickRadius = -1;
172 // Usually, from several objects that fall into the peak, the closest one along the ray is selected. However,
173 // if exactPickFirst = true, then the object in which the pick exactly fell (for example, a point in point cloud)
174 // will be returned as the result, even if there are others within the radius, including closer objects.
175 bool exactPickFirst = true;
176
177 // if not nullptr it can override render params for picker
179
180 // This will always return `{}`. We need the functions because `= {}`
181 // can't be used directly inside default arguments in the same class.
182 // You don't have to use this function.
184 {
185 return {};
186 }
187 };
188 // This function allows to pick point in scene by GL with given parameters.
189 // This overload uses all objects in the scene (possibly filtered by a predicate).
191 // This overload uses objects from the list (possibly filtered by a predicate).
192 MRVIEWER_API ObjAndPick pickRenderObject( std::span<VisualObject* const> objects, const PickRenderObjectParams& params = PickRenderObjectParams::defaults() ) const;
193 // This overload uses const objects from the list (possibly filtered by a predicate). Sadly need a different name to avoid over resolution issues.
194 MRVIEWER_API ConstObjAndPick pickRenderObjectConst( std::span<const VisualObject* const> objects, const PickRenderObjectParams& params = PickRenderObjectParams::defaults() ) const;
195
196 // This function allows to pick point in scene by GL
197 // use default pick radius
198 // comfortable usage:
199 // auto [obj,pick] = pick_render_object();
200 // pick all visible and pickable objects
201 // picks objects from current mouse pose by default
202 // [[deprecated("Use `pickRenderObject()`")]] // Should eventually deprecate this?
203 MRVIEWER_API ObjAndPick pick_render_object() const;
204 [[deprecated("Use `pickRenderObject()`")]]
205 MRVIEWER_API ObjAndPick pick_render_object( uint16_t pickRadius ) const;
206 // This function allows to pick point in scene by GL
207 // use default pick radius
208 // comfortable usage:
209 // auto [obj,pick] = pick_render_object( objects );
210 // pick objects from input
211 [[deprecated("Use `pickRenderObject( objects } )`")]] // NOTE! If your list is hardcoded, use `.objects = std::array{ a, b, c }`.
212 MRVIEWER_API ObjAndPick pick_render_object( const std::vector<VisualObject*>& objects ) const;
213 // This function allows to pick point in scene by GL with a given peak radius.
214 // usually, from several objects that fall into the peak, the closest one along the ray is selected.However
215 // if exactPickFirst = true, then the object in which the pick exactly fell( for example, a point in point cloud )
216 // will be returned as the result, even if there are others within the radius, including closer objects.
217 [[deprecated("Use `pickRenderObject( ... )`")]]
218 MRVIEWER_API ObjAndPick pick_render_object( const std::vector<VisualObject*>& objects, uint16_t pickRadius, bool exactPickFirst = true ) const;
219 // This function allows to pick point in scene by GL with default pick radius, but with specified exactPickFirst parameter (see description upper).
220 [[deprecated("Use `pickRenderObject( { .exactPickFirst = ... } )`")]]
221 MRVIEWER_API ObjAndPick pick_render_object( bool exactPickFirst ) const;
222 // This function allows to pick point in scene by GL
223 // comfortable usage:
224 // auto [obj,pick] = pick_render_object( objects );
225 // pick all visible and pickable objects
226 // picks objects from custom viewport point
227 [[deprecated("Use `pickRenderObject( { .point = ... } )`")]]
228 MRVIEWER_API ObjAndPick pick_render_object( const Vector2f& viewportPoint ) const;
229 // This function allows to pick point in scene by GL
230 // comfortable usage:
231 // auto [obj,pick] = pick_render_object( objects );
232 // picks objects from custom viewport point
233 [[deprecated("Use `multiPickObjects( objects, { .point = ... } )`")]]
234 MRVIEWER_API ObjAndPick pick_render_object( const std::vector<VisualObject*>& objects, const Vector2f& viewportPoint ) const;
235
236 // This function allows to pick several custom viewport space points by GL
237 // returns vector of pairs [obj,pick]
238 // To hardcode the list of `objects`, use `{{ a, b, c }}`.
239 MRVIEWER_API std::vector<ObjAndPick> multiPickObjects( std::span<VisualObject* const> objects, const std::vector<Vector2f>& viewportPoints, const BaseRenderParams* overrideRenderParams = nullptr ) const;
240
241 // This function finds all visible objects in given rect (max excluded) in viewport space,
242 // maxRenderResolutionSide - this parameter limits render resolution to improve performance
243 // if it is too small, little objects can be lost
244 // viewport space: X [0,viewport_width], Y [0,viewport_height] - (0,0) is upper left of viewport
245 MRVIEWER_API std::vector<std::shared_ptr<VisualObject>> findObjectsInRect( const Box2i& rect,
246 int maxRenderResolutionSide = 512 ) const;
247
248 // This functions finds all visible faces in given includePixBs in viewport space,
249 // maxRenderResolutionSide - this parameter limits render resolution to improve performance
250 // if it is too small, little faces can be lost
251 // viewport space: X [0,viewport_width], Y [0,viewport_height] - (0,0) is upper left of viewport
252 MRVIEWER_API std::unordered_map<std::shared_ptr<ObjectMesh>, FaceBitSet> findVisibleFaces( const BitSet& includePixBs,
253 int maxRenderResolutionSide = 512 ) const;
254
255 // This function allows to pick point in scene by GL
256 // comfortable usage:
257 // const auto [obj,pick] = pick_render_object();
258 // pick all visible and pickable objects
259 // picks objects from current mouse pose by default
260 [[deprecated("Use `pickRenderObject()`.")]]
262 // This function allows to pick point in scene by GL
263 // comfortable usage:
264 // const auto [obj,pick] = pick_render_object( objects );
265 // pick objects from input
266 [[deprecated("Use `pickRenderObject( objects )`.")]]
267 MRVIEWER_API ConstObjAndPick const_pick_render_object( const std::vector<const VisualObject*>& objects ) const;
268 // This function allows to pick several custom viewport space points by GL
269 // returns vector of pairs [obj,pick]
270 MRVIEWER_API std::vector<ConstObjAndPick> constMultiPickObjects( const std::vector<const VisualObject*>& objects, const std::vector<Vector2f>& viewportPoints ) const;
271
272 // multiplies view-matrix on given transformation from the _right_;
273 // so if you at the same time multiplies model transformation from the _left_ on xf.inverse()
274 // and call transformView( xf ), then the user will see exactly the same picture
275 MRVIEWER_API void transformView( const AffineXf3f & xf );
276
277 bool getRedrawFlag() const { return needRedraw_; }
278 void resetRedrawFlag() { needRedraw_ = false; }
279
280 // Unique identifier
282
284 {
285 Color backgroundColor = Color( Vector3f{0.3f, 0.3f, 0.5f} );
286 Vector3f lightPosition{0.0f, 0.3f, 0.0f};// x y z - position, w - factor
287
290 float cameraZoom{1.0f};
291 float cameraViewAngle{45.0f};
292 float cameraDnear{1.0f};
293 float cameraDfar{100.0f};
294
295 bool depthTest{true};
296 bool orthographic{true};
297
299 {
300 Auto, // uses current scene size
301 Fixed // uses global basis object internal size (one can change it with globalBasisAxes->setXf( AffineXf3f::linear( Matrix3f::scale( size ) ) ) )
302 } globalBasisScaleMode{ GlobalBasisScaleMode::Auto };
303
304 // Caches the two-norm between the min/max point of the bounding box
305 float objectScale{1.0f};
306
308
309 std::string label;
310
311 Plane3f clippingPlane{Vector3f::plusX(), 0.0f};
312
314 {
315 Static, // scene is always rotated around its center
316 DynamicStatic, // scene is rotated around picked point on object, or around center, if miss pick
317 Dynamic // scene is rotated around picked point on object, or around last rotation pivot, if miss pick
319
320 // if it is true, while rotation is enabled camera can be moved along forward axis
321 // in order to keep constant distance to scene center
322 bool compensateRotation{ true };
323
324 // this flag allows viewport to be selected by user
325 bool selectable{true};
326
327 bool operator==( const Viewport::Parameters& other ) const = default;
328 };
329
330 // Starts or stop rotation
331 MRVIEWER_API void setRotation( bool state );
332
333 // Note, Y is up for this box.
334 MRVIEWER_API const ViewportRectangle& getViewportRect() const;
335
336 // Finds length between near pixels on zNear plane. Only good in the orthographic projection.
337 MRVIEWER_API float getPixelSize() const;
338
339 // Finds the pixel scale at a specific world point. This works in both perspective and orthographic projection.
340 // The UI scale is NOT baked into this. You have to multiply by the scale manually if you need that.
341 MRVIEWER_API float getPixelSizeAtPoint( const Vector3f& worldPoint ) const;
342
343 // Sets position and size of viewport:
344 // rect is given as OpenGL coordinates: (0,0) is lower left corner
345 MRVIEWER_API void setViewportRect( const ViewportRectangle& rect );
346
347private:
348 // Save the OpenGL transformation matrices used for the previous rendering pass
349 Matrix4f viewM_;
350 Matrix4f projM_;
351
352public:
354 [[nodiscard]] MRVIEWER_API AffineXf3f getUnscaledViewXf() const;
355
357 [[nodiscard]] AffineXf3f getViewXf() const { return AffineXf3f( viewM_ ); }
358
360 [[nodiscard]] Vector3f getUpDirection() const { return Vector3f( viewM_.y.x, viewM_.y.y, viewM_.y.z ).normalized(); } // assume that viewM is orthogonal and inverse=transpose
361
363 [[nodiscard]] Vector3f getRightDirection() const { return Vector3f( viewM_.x.x, viewM_.x.y, viewM_.x.z ).normalized(); } // assume that viewM is orthogonal and inverse=transpose
364
366 [[nodiscard]] Vector3f getBackwardDirection() const { return Vector3f( viewM_.z.x, viewM_.z.y, viewM_.z.z ).normalized(); } // assume that viewM is orthogonal and inverse=transpose
367
368 // returns the line from Dnear to Dfar planes for the current pixel
369 // viewport space: X [0,viewport_width], Y [0,viewport_height] - (0,0) is upper left of viewport
370 // Z [0.f,1.f] - 0.f is Dnear, 1.f is Dfar
371 MRVIEWER_API Line3f unprojectPixelRay( const Vector2f& viewportPoint ) const;
372
373 // convert point(s) to camera space by applying view matrix
374 MRVIEWER_API Vector3f worldToCameraSpace( const Vector3f& p ) const;
375 MRVIEWER_API std::vector<Vector3f> worldToCameraSpace( const std::vector<Vector3f>& p ) const;
376
377 // projects point(s) to clip space. (rather, to normalized device coordinates, as it includes perspective division)
378 // clip space: XYZ [-1.f, 1.f], X axis from left(-1.f) to right(1.f), Y axis from bottom(-1.f) to top(1.f),
379 // Z axis from Dnear(-1.f) to Dfar(1.f)
380 MRVIEWER_API Vector3f projectToClipSpace( const Vector3f& worldPoint ) const;
381 MRVIEWER_API std::vector<Vector3f> projectToClipSpace( const std::vector<Vector3f>& worldPoints ) const;
382 MRVIEWER_API Vector3f unprojectFromClipSpace( const Vector3f& clipPoint ) const;
383 MRVIEWER_API std::vector<Vector3f> unprojectFromClipSpace( const std::vector<Vector3f>& clipPoints ) const;
384
385 // project point and convert coordinates to viewport space
386 // viewport space: X [0,viewport_width], Y [0,viewport_height] - (0,0) is upper left of viewport
387 // Z [0.f,1.f] - 0.f is Dnear, 1.f is Dfar
388 MRVIEWER_API Vector3f projectToViewportSpace( const Vector3f& worldPoint ) const;
389 MRVIEWER_API std::vector<Vector3f> projectToViewportSpace( const std::vector<Vector3f>& worldPoints ) const;
390 // unproject coordinates from viewport space
391 // viewport space: X [0,viewport_width], Y [0,viewport_height] - (0,0) is upper left of viewport
392 // Z [0.f,1.f] - 0.f is Dnear, 1.f is Dfar
393 MRVIEWER_API Vector3f unprojectFromViewportSpace( const Vector3f& viewportPoint ) const;
394 MRVIEWER_API std::vector<Vector3f> unprojectFromViewportSpace( const std::vector<Vector3f>& viewportPoints ) const;
395
396 // conversations between clip space and viewport space
397 // clip space: XYZ [-1.f, 1.f], X axis from left(-1.f) to right(1.f), Y axis from bottom(-1.f) to top(1.f),
398 // Z axis from Dnear(-1.f) to Dfar(1.f)
399 // viewport space: X [0,viewport_width], Y [0,viewport_height] - (0,0) is upper left of viewport
400 // Z [0.f,1.f] - 0.f is Dnear, 1.f is Dfar
401 MRVIEWER_API Vector3f clipSpaceToViewportSpace( const Vector3f& p ) const;
402 MRVIEWER_API std::vector<Vector3f> clipSpaceToViewportSpace( const std::vector<Vector3f>& p ) const;
403 MRVIEWER_API Vector3f viewportSpaceToClipSpace( const Vector3f& p ) const;
404 MRVIEWER_API std::vector<Vector3f> viewportSpaceToClipSpace( const std::vector<Vector3f>& p ) const;
405
406 // updates view and projection matrices due to camera parameters (called each frame)
407 void setupView();
408 // draws viewport primitives:
409 // lines: if depth test is on
410 // points: if depth test is on
411 // rotation center
412 // global basis
413 void preDraw();
414 // draws viewport primitives:
415 // lines: if depth test is off
416 // points: if depth test is off
417 // viewport border
418 // overlay basis
419 void postDraw() const;
420
421 // fit camera to the scene box (note: scene box does not include ancillary objects)
422 // fill = 1.0 parameter means that scene will be approximately 0.5 of screen
423 // snapView - to snap camera angle to closest canonical quaternion
424 MRVIEWER_API void fitData( float fill = 1.0f, bool snapView = true );
425
426 // set scene box by given one and fit camera to it
427 // fill = 1.0 parameter means that box diagonal will be approximately 0.5 of the viewport
428 // snapView - to snap camera angle to closest canonical quaternion
429 MRVIEWER_API void fitBox( const Box3f& newSceneBox, float fill = 1.0f, bool snapView = true );
430
435
436 // fit view and proj matrices to match the screen size with given box
437 MRVIEWER_API void preciseFitBoxToScreenBorder( const FitBoxParams& params );
438 // fit view and proj matrices to match the screen size with given objects
439 MRVIEWER_API void preciseFitDataToScreenBorder( const FitDataParams& params = {} );
440
441 // returns viewport width/height ratio
442 MRVIEWER_API float getRatio() const;
443
444 // returns true if all models are fully projected inside the viewport rectangle
445 MRVIEWER_API bool allModelsInsideViewportRectangle() const;
446
447 MRVIEWER_API const Box3f& getSceneBox() const;
448
449 const Parameters& getParameters() const { return params_; }
450
451 // returns camera world location for the current view
452 MRVIEWER_API Vector3f getCameraPoint() const;
453 // sets camera world location for the current view
454 MRVIEWER_API void setCameraPoint( const Vector3f& cameraWorldPos );
455
456 MRVIEWER_API void setCameraTrackballAngle( const Quaternionf& rot );
457
458 MRVIEWER_API void setCameraTranslation( const Vector3f& translation );
459
460 MRVIEWER_API void setCameraViewAngle( float newViewAngle );
461
462 MRVIEWER_API void setCameraZoom( float zoom );
463
464 MRVIEWER_API void setOrthographic( bool orthographic );
465
466 MRVIEWER_API void setBackgroundColor( const Color& color );
467
468 MRVIEWER_API void setClippingPlane( const Plane3f& plane );
469
470 MRVIEWER_API void setLabel( std::string s );
471
472 void setSelectable( bool on ) { params_.selectable = on; }
473
474 MRVIEWER_API void showAxes( bool on );
475 MRVIEWER_API void showClippingPlane( bool on );
476 MRVIEWER_API void showRotationCenter( bool on );
477 MRVIEWER_API void showGlobalBasis( bool on );
479
480 MRVIEWER_API void setParameters( const Viewport::Parameters& params );
481
482 // Set camera look direction and up direction (they should be perpendicular)
483 // this function changes camera position and do not change camera spot (0,0,0) by default
484 // to change camera position use setCameraTranslation after this function
485 MRVIEWER_API void cameraLookAlong( const Vector3f& dir, const Vector3f& up );
486
487 // Rotates camera around axis +direction applied to axis point
488 // note: this can make camera clip objects (as far as distance to scene center is not fixed)
489 MRVIEWER_API void cameraRotateAround( const Line3f& axis, float angle );
490
491 // Get current rotation pivot in world space
492 MRVIEWER_API Vector3f getRotationPivot() const;
493
494private:
495 // initializes view matrix based on camera position
496 void setupViewMatrix_();
497 // returns world space to camera space transformation
498 AffineXf3f getViewXf_() const;
499
500 // initializes proj matrix based on camera angle and viewport rectangle size
501 void setupProjMatrix_();
502 // initializes proj matrix for static view objects (like corner axes)
503 void setupAxesProjMatrix_();
504
505 // use this matrix to convert world 3d point to clip point
506 // clip space: XYZ [-1.f, 1.f], X axis from left(-1.f) to right(1.f), X axis from bottom(-1.f) to top(1.f),
507 // Z axis from Dnear(-1.f) to Dfar(1.f)
508 Matrix4f getFullViewportMatrix() const { return projM_ * viewM_; }
509 Matrix4f getFullViewportInversedMatrix() const;
510
511 ViewportRectangle viewportRect_;
512
513 ViewportGL viewportGL_;
514
515 bool previewLinesDepthTest_ = false;
516 bool previewPointsDepthTest_ = false;
517
518 void draw_border() const;
519 void draw_rotation_center() const;
520 void draw_clipping_plane() const;
521 void draw_global_basis() const;
522
523 // init basis axis in the corner
524 void initBaseAxes();
525 // Drawing basis axes and view controller cube in the corner
526 void drawAxesAndViewController() const;
527
528 // This matrix should be used for a static objects
529 // For example, basis axes in the corner
530 Matrix4f axesProjMat_;
531 Vector2f basisAxesPos_;
532 float basisAxesSize_;
533
534 // basis axis params
535 int pixelXoffset_{ -100 };
536 int pixelYoffset_{ -100 };
537 int axisPixSize_{ 70 };
538
539 // Receives point in scene coordinates, that should appear static on a screen, while rotation
540 void setRotationPivot_( const Vector3f& point );
541 void updateSceneBox_();
542 void rotateView_();
543
544 enum class Space
545 {
546 World, // (x, y, z) in world space
547 CameraOrthographic, // (x, y, z) in camera space
548 CameraPerspective // (x/z, y/z, z), where (x, y, z) in camera space
549 };
550
555 Box3f calcBox_( const std::vector<std::shared_ptr<VisualObject>>& objs, Space space, bool selectedPrimitives = false ) const;
556
564 std::pair<float, bool> getZoomFOVtoScreen_( std::function<Box3f()> getBoxFn, Vector3f* cameraShift = nullptr ) const;
565 // fit view and proj matrices to match the screen size with boxes returned by getBoxFn
566 // getBoxFn( true ) - always camera space (respecting projection)
567 // getBoxFn( false ) - if orthographic - camera space, otherwise - world space
568 // getBoxFn/globalBasis - if true then getBoxFn should return box of global basis object (separately, not to interfere with actual scene size)
569 void preciseFitToScreenBorder_( std::function<Box3f( bool zoomFOV, bool globalBasis )> getBoxFn, const BaseFitParams& params );
570
571 bool rotation_{ false };
572 Vector3f rotationPivot_;
573 Vector3f static_point_;
574 Vector2f static_viewport_point;
575 float distToSceneCenter_;
576
577 bool needRedraw_{false};
578
579 // world bounding box of scene objects visible in this viewport
580 Box3f sceneBox_;
581
582 Parameters params_;
583};
584
585} //namespace MR
container of bits
Definition MRMesh/MRBitSet.h:27
Definition MRViewportGL.h:53
Definition MRViewportId.h:16
stores mask of viewport unique identifiers
Definition MRViewportId.h:38
Definition MRViewport.h:46
MRVIEWER_API Vector3f projectToClipSpace(const Vector3f &worldPoint) const
MRVIEWER_API void showRotationCenter(bool on)
MRVIEWER_API ConstObjAndPick const_pick_render_object() const
MRVIEWER_API Vector3f projectToViewportSpace(const Vector3f &worldPoint) const
MRVIEWER_API void setCameraViewAngle(float newViewAngle)
MRVIEWER_API void setCameraZoom(float zoom)
MRVIEWER_API ObjAndPick pick_render_object(const std::vector< VisualObject * > &objects, uint16_t pickRadius, bool exactPickFirst=true) const
MRVIEWER_API void shut()
MR::BaseFitParams BaseFitParams
Definition MRViewport.h:432
MRVIEWER_API float getAxesSize() const
MRVIEWER_API ObjAndPick pick_render_object(const std::vector< VisualObject * > &objects, const Vector2f &viewportPoint) const
Vector3f getRightDirection() const
returns unit vector in world space corresponding to right-direction in camera space
Definition MRViewport.h:363
ModelRenderParams getModelRenderParams(const Matrix4f &modelM, Matrix4f *normM, DepthFunction depthFunc=DepthFunction::Default, RenderModelPassMask pass=RenderModelPassMask::All, bool allowAlphaSort=false) const
Prepares rendering parameters to draw a model with given transformation in this viewport.
Definition MRViewport.h:141
MRVIEWER_API ~Viewport()
MRVIEWER_API std::vector< Vector3f > unprojectFromViewportSpace(const std::vector< Vector3f > &viewportPoints) const
MRVIEWER_API void cameraLookAlong(const Vector3f &dir, const Vector3f &up)
MRVIEWER_API Vector3f unprojectFromClipSpace(const Vector3f &clipPoint) const
MRVIEWER_API ObjAndPick pick_render_object(uint16_t pickRadius) const
MRVIEWER_API ConstObjAndPick pickRenderObjectConst(std::span< const VisualObject *const > objects, const PickRenderObjectParams &params=PickRenderObjectParams::defaults()) const
MRVIEWER_API void showGlobalBasis(bool on)
std::function< bool(const VisualObject *, ViewportMask)> PickRenderObjectPredicate
Definition MRViewport.h:159
MRVIEWER_API void cameraRotateAround(const Line3f &axis, float angle)
MRVIEWER_API ModelRenderParams getModelRenderParams(const Matrix4f &modelM, const Matrix4f &projM, Matrix4f *normM, DepthFunction depthFunc=DepthFunction::Default, RenderModelPassMask pass=RenderModelPassMask::All, bool allowAlphaSort=false) const
Prepares rendering parameters to draw a model with given transformation in this viewport with custom ...
MRVIEWER_API void setCameraTranslation(const Vector3f &translation)
MRVIEWER_API ObjAndPick pickRenderObject(const PickRenderObjectParams &params=PickRenderObjectParams::defaults()) const
bool getRedrawFlag() const
Definition MRViewport.h:277
BaseRenderParams getBaseRenderParams(const Matrix4f &projM) const
Prepares base rendering parameters for this viewport with custom projection matrix.
Definition MRViewport.h:137
MRVIEWER_API float getRatio() const
void setSelectable(bool on)
Definition MRViewport.h:472
MRVIEWER_API float getPixelSize() const
MRVIEWER_API ConstObjAndPick const_pick_render_object(const std::vector< const VisualObject * > &objects) const
MRVIEWER_API Vector3f unprojectFromViewportSpace(const Vector3f &viewportPoint) const
MRVIEWER_API const Vector2f & getAxesPosition() const
returns position of basis axes in viewport space
void drawLines(const std::vector< LineSegm3f > &lines, const std::vector< SegmEndColors > &colors, float width=1, bool depthTest=true)
Definition MRViewport.h:116
MRVIEWER_API void init()
MRVIEWER_API float getPixelSizeAtPoint(const Vector3f &worldPoint) const
void resetRedrawFlag()
Definition MRViewport.h:278
MRVIEWER_API void preciseFitDataToScreenBorder(const FitDataParams &params={})
MRVIEWER_API Vector3f viewportSpaceToClipSpace(const Vector3f &p) const
MR::ViewportRectangle ViewportRectangle
Definition MRViewport.h:48
MRVIEWER_API void setRotation(bool state)
MRVIEWER_API void setParameters(const Viewport::Parameters &params)
MRVIEWER_API std::vector< Vector3f > clipSpaceToViewportSpace(const std::vector< Vector3f > &p) const
MRVIEWER_API bool draw(const VisualObject &obj, const AffineXf3f &xf, DepthFunction depthFunc=DepthFunction::Default, RenderModelPassMask pass=RenderModelPassMask::All, bool allowAlphaSort=false) const
MRVIEWER_API void setOrthographic(bool orthographic)
AffineXf3f getViewXf() const
converts directly from the view matrix
Definition MRViewport.h:357
void preDraw()
MRVIEWER_API void showClippingPlane(bool on)
MRVIEWER_API const ViewportRectangle & getViewportRect() const
MRVIEWER_API void fitBox(const Box3f &newSceneBox, float fill=1.0f, bool snapView=true)
MRVIEWER_API void showAxes(bool on)
MRVIEWER_API std::vector< Vector3f > worldToCameraSpace(const std::vector< Vector3f > &p) const
MRVIEWER_API Vector3f getCameraPoint() const
MRVIEWER_API void drawTris(const std::vector< Triangle3f > &tris, const std::vector< TriCornerColors > &colors, const Matrix4f &modelM={}, bool depthTest=true)
MRVIEWER_API void drawTris(const std::vector< Triangle3f > &tris, const std::vector< TriCornerColors > &colors, const ModelRenderParams &params, bool depthTest=true)
Draw triangles immediately (flat shaded)
MRVIEWER_API void setCameraTrackballAngle(const Quaternionf &rot)
MRVIEWER_API ObjAndPick pick_render_object(const std::vector< VisualObject * > &objects) const
Vector3f getBackwardDirection() const
returns unit vector in world space corresponding to direction toward camera in camera space
Definition MRViewport.h:366
MRVIEWER_API Line3f unprojectPixelRay(const Vector2f &viewportPoint) const
MRVIEWER_API std::vector< Vector3f > unprojectFromClipSpace(const std::vector< Vector3f > &clipPoints) const
Viewport clone() const
Definition MRViewport.h:61
MRVIEWER_API void setLabel(std::string s)
MRVIEWER_API bool draw(const VisualObject &obj, const AffineXf3f &xf, const Matrix4f &projM, DepthFunction depthFunc=DepthFunction::Default, RenderModelPassMask pass=RenderModelPassMask::All, bool allowAlphaSort=false) const
MRVIEWER_API std::unordered_map< std::shared_ptr< ObjectMesh >, FaceBitSet > findVisibleFaces(const BitSet &includePixBs, int maxRenderResolutionSide=512) const
const Parameters & getParameters() const
Definition MRViewport.h:449
MRVIEWER_API std::vector< Vector3f > viewportSpaceToClipSpace(const std::vector< Vector3f > &p) const
MRVIEWER_API std::vector< Vector3f > projectToViewportSpace(const std::vector< Vector3f > &worldPoints) const
MRVIEWER_API void fitData(float fill=1.0f, bool snapView=true)
MRVIEWER_API void setAxesSize(const int axisPixSize=80)
MRVIEWER_API void drawPoints(const std::vector< Vector3f > &points, const std::vector< Vector4f > &colors, const LinePointImmediateRenderParams &params)
Draw points immediately.
MRVIEWER_API const Box3f & getSceneBox() const
static MRVIEWER_API Viewport & get(ViewportId viewportId={})
void setupView()
MRVIEWER_API ObjAndPick pickRenderObject(std::span< VisualObject *const > objects, const PickRenderObjectParams &params=PickRenderObjectParams::defaults()) const
MRVIEWER_API void setViewportRect(const ViewportRectangle &rect)
Viewport(Viewport &&) noexcept=default
MRVIEWER_API std::vector< ObjAndPick > multiPickObjects(std::span< VisualObject *const > objects, const std::vector< Vector2f > &viewportPoints, const BaseRenderParams *overrideRenderParams=nullptr) const
MRVIEWER_API void transformView(const AffineXf3f &xf)
MRVIEWER_API Vector3f worldToCameraSpace(const Vector3f &p) const
MRVIEWER_API ObjAndPick pick_render_object(bool exactPickFirst) const
MRVIEWER_API std::vector< ConstObjAndPick > constMultiPickObjects(const std::vector< const VisualObject * > &objects, const std::vector< Vector2f > &viewportPoints) const
MRVIEWER_API bool draw(const VisualObject &obj, DepthFunction depthFunc=DepthFunction::Default, RenderModelPassMask pass=RenderModelPassMask::All, bool allowAlphaSort=false) const
MRVIEWER_API AffineXf3f getUnscaledViewXf() const
returns orthonormal matrix with translation
const Matrix4f & getAxesProjectionMatrix() const
returns projection matrix that is used for basis axes and view controller rendering
Definition MRViewport.h:82
MRVIEWER_API void setClippingPlane(const Plane3f &plane)
MRVIEWER_API void preciseFitBoxToScreenBorder(const FitBoxParams &params)
MRVIEWER_API bool allModelsInsideViewportRectangle() const
void postDraw() const
BaseRenderParams getBaseRenderParams() const
Prepares base rendering parameters for this viewport.
Definition MRViewport.h:134
MRVIEWER_API void drawLines(const std::vector< LineSegm3f > &lines, const std::vector< SegmEndColors > &colors, const LinePointImmediateRenderParams &params)
Draw lines immediately.
void drawPoints(const std::vector< Vector3f > &points, const std::vector< Vector4f > &colors, float width=1, bool depthTest=true)
Definition MRViewport.h:121
MRVIEWER_API Viewport()
MRVIEWER_API void setBackgroundColor(const Color &color)
MRVIEWER_API Vector3f getRotationPivot() const
MRVIEWER_API std::vector< std::shared_ptr< VisualObject > > findObjectsInRect(const Box2i &rect, int maxRenderResolutionSide=512) const
MRVIEWER_API void setAxesPos(const int pixelXoffset=-100, const int pixelYoffset=-100)
MRVIEWER_API void clearFramebuffers()
MRVIEWER_API ObjAndPick pick_render_object(const Vector2f &viewportPoint) const
MRVIEWER_API void setCameraPoint(const Vector3f &cameraWorldPos)
MRVIEWER_API Vector3f clipSpaceToViewportSpace(const Vector3f &p) const
ViewportId id
Definition MRViewport.h:281
MRVIEWER_API std::vector< Vector3f > projectToClipSpace(const std::vector< Vector3f > &worldPoints) const
MRVIEWER_API void rotationCenterMode(Parameters::RotationCenterMode mode)
Vector3f getUpDirection() const
returns unit vector in world space corresponding to up-direction in camera space
Definition MRViewport.h:360
MRVIEWER_API ObjAndPick pick_render_object() const
Visual Object.
Definition MRVisualObject.h:121
auto width(const Box< V > &box)
returns size along x axis
Definition MRMesh/MRBox.h:288
auto height(const Box< V > &box)
returns size along y axis
Definition MRMesh/MRBox.h:295
FitMode
Definition MRFitData.h:11
ImVec2 size(const ViewportRectangle &rect)
Definition MRViewport.h:29
std::pair< std::shared_ptr< MR::VisualObject >, MR::PointOnObject > ObjAndPick
Definition MRViewerFwd.h:69
RenderModelPassMask
Various passes of the 3D rendering.
Definition MRRenderModelParameters.h:10
std::pair< std::shared_ptr< const MR::VisualObject >, MR::PointOnObject > ConstObjAndPick
Definition MRViewerFwd.h:70
Vector4< T > toVec4(const ViewportRectangle &rect)
Definition MRViewport.h:38
DepthFunction
Definition MRIRenderObject.h:18
Box2f ViewportRectangle
Viewport size.
Definition MRViewerFwd.h:12
Definition MRFitData.h:19
Common rendering parameters for meshes and UI.
Definition MRIRenderObject.h:33
Definition MRMesh/MRColor.h:9
Definition MRFitData.h:41
Definition MRFitData.h:28
Mesh rendering parameters for primary rendering (as opposed to the picker).
Definition MRIRenderObject.h:51
Definition MRVector4.h:20
Rendering parameters for immediate drawing of lines and points.
Definition MRViewport.h:109
bool depthTest
Definition MRViewport.h:111
float width
Definition MRViewport.h:110
Definition MRViewport.h:284
RotationCenterMode
Definition MRViewport.h:314
float cameraViewAngle
Definition MRViewport.h:291
Vector3f cameraTranslation
Definition MRViewport.h:289
Color backgroundColor
Definition MRViewport.h:285
bool orthographic
Definition MRViewport.h:296
float cameraDfar
Definition MRViewport.h:293
Color borderColor
Definition MRViewport.h:307
bool depthTest
Definition MRViewport.h:295
Plane3f clippingPlane
Definition MRViewport.h:311
std::string label
Definition MRViewport.h:309
float cameraZoom
Definition MRViewport.h:290
Quaternionf cameraTrackballAngle
Definition MRViewport.h:288
Vector3f lightPosition
Definition MRViewport.h:286
enum MR::Viewport::Parameters::GlobalBasisScaleMode Auto
bool selectable
Definition MRViewport.h:325
GlobalBasisScaleMode
Definition MRViewport.h:299
enum MR::Viewport::Parameters::RotationCenterMode Dynamic
bool operator==(const Viewport::Parameters &other) const =default
float cameraDnear
Definition MRViewport.h:292
bool compensateRotation
Definition MRViewport.h:322
float objectScale
Definition MRViewport.h:305
Definition MRViewport.h:162
int pickRadius
Definition MRViewport.h:171
PickRenderObjectPredicate predicate
Definition MRViewport.h:167
bool exactPickFirst
Definition MRViewport.h:175
static PickRenderObjectParams defaults()
Definition MRViewport.h:183
const BaseRenderParams * baseRenderParams
Definition MRViewport.h:178
std::optional< Vector2f > point
Definition MRViewport.h:164
Definition MRViewport.h:125
Vector4f c
Definition MRViewport.h:126
Vector4f b
Definition MRViewport.h:126
Vector4f a
Definition MRViewport.h:126