/** * @file llviewerwindow.h * @brief Description of the LLViewerWindow class. * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ // // A note about X,Y coordinates: // // X coordinates are in pixels, from the left edge of the window client area // Y coordinates are in pixels, from the BOTTOM edge of the window client area // // The Y coordinates therefore match OpenGL window coords, not Windows(tm) window coords. // If Y is from the top, the variable will be called "y_from_top" #ifndef LL_LLVIEWERWINDOW_H #define LL_LLVIEWERWINDOW_H #include "v3dmath.h" #include "v2math.h" #include "llcursortypes.h" #include "llwindowcallbacks.h" #include "lltimer.h" #include "llmousehandler.h" #include "llnotifications.h" #include "llhandle.h" #include "llinitparam.h" #include "lltrace.h" #include "llsnapshotmodel.h" #include <boost/function.hpp> #include <boost/signals2.hpp> class LLView; class LLViewerObject; class LLUUID; class LLProgressView; class LLTool; class LLVelocityBar; class LLPanel; class LLImageRaw; class LLImageFormatted; class LLHUDIcon; class LLWindow; class LLRootView; class LLWindowListener; class LLViewerWindowListener; class LLVOPartGroup; class LLPopupView; class LLCubeMap; class LLCubeMapArray; #define PICK_HALF_WIDTH 5 #define PICK_DIAMETER (2 * PICK_HALF_WIDTH + 1) class LLPickInfo { public: typedef enum { PICK_OBJECT, PICK_FLORA, PICK_LAND, PICK_ICON, PICK_PARCEL_WALL, PICK_INVALID } EPickType; public: LLPickInfo(); LLPickInfo(const LLCoordGL& mouse_pos, MASK keyboard_mask, bool pick_transparent, bool pick_rigged, bool pick_particle, bool pick_reflection_probe, bool pick_surface_info, bool pick_unselectable, void (*pick_callback)(const LLPickInfo& pick_info)); void fetchResults(); LLPointer<LLViewerObject> getObject() const; LLUUID getObjectID() const { return mObjectID; } bool isValid() const { return mPickType != PICK_INVALID; } static bool isFlora(LLViewerObject* object); public: LLCoordGL mMousePt; MASK mKeyMask; void (*mPickCallback)(const LLPickInfo& pick_info); EPickType mPickType; LLCoordGL mPickPt; LLVector3d mPosGlobal; LLVector3 mObjectOffset; LLUUID mObjectID; LLUUID mParticleOwnerID; LLUUID mParticleSourceID; S32 mObjectFace; S32 mGLTFNodeIndex = -1; S32 mGLTFPrimitiveIndex = -1; LLHUDIcon* mHUDIcon; LLVector3 mIntersection; LLVector2 mUVCoords; LLVector2 mSTCoords; LLCoordScreen mXYCoords; LLVector3 mNormal; LLVector4 mTangent; LLVector3 mBinormal; bool mPickTransparent; bool mPickRigged; bool mPickParticle; bool mPickUnselectable; bool mPickReflectionProbe = false; void getSurfaceInfo(); private: void updateXYCoords(); bool mWantSurfaceInfo; // do we populate mUVCoord, mNormal, mBinormal? }; static const U32 MAX_SNAPSHOT_IMAGE_SIZE = 7680; // max snapshot image size 7680 * 7680 UHDTV2 class LLViewerWindow : public LLWindowCallbacks { public: // // CREATORS // struct Params : public LLInitParam::Block<Params> { Mandatory<std::string> title, name; Mandatory<S32> x, y, width, height, min_width, min_height; Optional<bool> fullscreen, ignore_pixel_depth, first_run; Params(); }; LLViewerWindow(const Params& p); virtual ~LLViewerWindow(); void shutdownViews(); void shutdownGL(); void initGLDefaults(); void initBase(); void adjustRectanglesForFirstUse(const LLRect& window); void adjustControlRectanglesForFirstUse(const LLRect& window); void initWorldUI(); void setUIVisibility(bool); bool getUIVisibility(); void handlePieMenu(S32 x, S32 y, MASK mask); void reshapeStatusBarContainer(); void resetStatusBarContainer(); // undo changes done by resetStatusBarContainer on initWorldUI() bool handleAnyMouseClick(LLWindow *window, LLCoordGL pos, MASK mask, EMouseClickType clicktype, bool down, bool &is_toolmgr_action); // // LLWindowCallback interface implementation // /*virtual*/ bool handleTranslatedKeyDown(KEY key, MASK mask, bool repeated); /*virtual*/ bool handleTranslatedKeyUp(KEY key, MASK mask); /*virtual*/ void handleScanKey(KEY key, bool key_down, bool key_up, bool key_level); /*virtual*/ bool handleUnicodeChar(llwchar uni_char, MASK mask); // NOT going to handle extended /*virtual*/ bool handleMouseDown(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ bool handleMouseUp(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ bool handleCloseRequest(LLWindow *window); /*virtual*/ void handleQuit(LLWindow *window); /*virtual*/ bool handleRightMouseDown(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ bool handleRightMouseUp(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ bool handleMiddleMouseDown(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ bool handleMiddleMouseUp(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ bool handleOtherMouseDown(LLWindow *window, LLCoordGL pos, MASK mask, S32 button); /*virtual*/ bool handleOtherMouseUp(LLWindow *window, LLCoordGL pos, MASK mask, S32 button); bool handleOtherMouse(LLWindow *window, LLCoordGL pos, MASK mask, S32 button, bool down); /*virtual*/ LLWindowCallbacks::DragNDropResult handleDragNDrop(LLWindow *window, LLCoordGL pos, MASK mask, LLWindowCallbacks::DragNDropAction action, std::string data); void handleMouseMove(LLWindow *window, LLCoordGL pos, MASK mask); void handleMouseDragged(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ void handleMouseLeave(LLWindow *window); /*virtual*/ void handleResize(LLWindow *window, S32 x, S32 y); /*virtual*/ void handleFocus(LLWindow *window); /*virtual*/ void handleFocusLost(LLWindow *window); /*virtual*/ bool handleActivate(LLWindow *window, bool activated); /*virtual*/ bool handleActivateApp(LLWindow *window, bool activating); /*virtual*/ void handleMenuSelect(LLWindow *window, S32 menu_item); /*virtual*/ bool handlePaint(LLWindow *window, S32 x, S32 y, S32 width, S32 height); /*virtual*/ void handleScrollWheel(LLWindow *window, S32 clicks); /*virtual*/ void handleScrollHWheel(LLWindow *window, S32 clicks); /*virtual*/ bool handleDoubleClick(LLWindow *window, LLCoordGL pos, MASK mask); /*virtual*/ void handleWindowBlock(LLWindow *window); /*virtual*/ void handleWindowUnblock(LLWindow *window); /*virtual*/ void handleDataCopy(LLWindow *window, S32 data_type, void *data); /*virtual*/ bool handleTimerEvent(LLWindow *window); /*virtual*/ bool handleDeviceChange(LLWindow *window); /*virtual*/ bool handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32 window_width, S32 window_height); /*virtual*/ bool handleWindowDidChangeScreen(LLWindow *window); /*virtual*/ void handlePingWatchdog(LLWindow *window, const char * msg); /*virtual*/ void handlePauseWatchdog(LLWindow *window); /*virtual*/ void handleResumeWatchdog(LLWindow *window); /*virtual*/ std::string translateString(const char* tag); /*virtual*/ std::string translateString(const char* tag, const std::map<std::string, std::string>& args); // signal on update of WorldView rect typedef boost::function<void (LLRect old_world_rect, LLRect new_world_rect)> world_rect_callback_t; typedef boost::signals2::signal<void (LLRect old_world_rect, LLRect new_world_rect)> world_rect_signal_t; world_rect_signal_t mOnWorldViewRectUpdated; boost::signals2::connection setOnWorldViewRectUpdated(world_rect_callback_t cb) { return mOnWorldViewRectUpdated.connect(cb); } // // ACCESSORS // LLRootView* getRootView() const; // 3D world area in scaled pixels (via UI scale), use for most UI computations LLRect getWorldViewRectScaled() const; S32 getWorldViewHeightScaled() const; S32 getWorldViewWidthScaled() const; // 3D world area, in raw unscaled pixels LLRect getWorldViewRectRaw() const { return mWorldViewRectRaw; } S32 getWorldViewHeightRaw() const; S32 getWorldViewWidthRaw() const; // Window in scaled pixels (via UI scale), use for most UI computations LLRect getWindowRectScaled() const { return mWindowRectScaled; } S32 getWindowHeightScaled() const; S32 getWindowWidthScaled() const; // Window in raw pixels as seen on screen. LLRect getWindowRectRaw() const { return mWindowRectRaw; } S32 getWindowHeightRaw() const; S32 getWindowWidthRaw() const; LLWindow* getWindow() const { return mWindow; } void* getPlatformWindow() const; void* getMediaWindow() const; void focusClient() const; LLCoordGL getLastMouse() const { return mLastMousePoint; } S32 getLastMouseX() const { return mLastMousePoint.mX; } S32 getLastMouseY() const { return mLastMousePoint.mY; } LLCoordGL getCurrentMouse() const { return mCurrentMousePoint; } S32 getCurrentMouseX() const { return mCurrentMousePoint.mX; } S32 getCurrentMouseY() const { return mCurrentMousePoint.mY; } S32 getCurrentMouseDX() const { return mCurrentMouseDelta.mX; } S32 getCurrentMouseDY() const { return mCurrentMouseDelta.mY; } LLCoordGL getCurrentMouseDelta() const { return mCurrentMouseDelta; } static LLTrace::SampleStatHandle<>* getMouseVelocityStat() { return &sMouseVelocityStat; } bool getLeftMouseDown() const { return mLeftMouseDown; } bool getMiddleMouseDown() const { return mMiddleMouseDown; } bool getRightMouseDown() const { return mRightMouseDown; } const LLPickInfo& getLastPick() const { return mLastPick; } void setup2DViewport(S32 x_offset = 0, S32 y_offset = 0); void setup3DViewport(S32 x_offset = 0, S32 y_offset = 0); void setup3DRender(); void setup2DRender(); LLVector3 mouseDirectionGlobal(const S32 x, const S32 y) const; LLVector3 mouseDirectionCamera(const S32 x, const S32 y) const; LLVector3 mousePointHUD(const S32 x, const S32 y) const; // Is window of our application frontmost? bool getActive() const { return mActive; } const std::string& getInitAlert() { return mInitAlert; } // // MANIPULATORS // void saveLastMouse(const LLCoordGL &point); void setCursor( ECursorType c ); void showCursor(); void hideCursor(); bool getCursorHidden() { return mCursorHidden; } void moveCursorToCenter(); // move to center of window void initTextures(S32 location_id); void setShowProgress(const bool show); bool getShowProgress() const; void setProgressString(const std::string& string); void setProgressPercent(const F32 percent); void setProgressMessage(const std::string& msg); void setProgressCancelButtonVisible( bool b, const std::string& label = LLStringUtil::null ); LLProgressView *getProgressView() const; void revealIntroPanel(); void setStartupComplete(); void updateObjectUnderCursor(); void updateUI(); // Once per frame, update UI based on mouse position, calls following update* functions void updateLayout(); void updateMouseDelta(); void updateKeyboardFocus(); void updateWorldViewRect(bool use_full_window=false); LLView* getToolBarHolder() { return mToolBarHolder.get(); } LLView* getHintHolder() { return mHintHolder.get(); } LLView* getLoginPanelHolder() { return mLoginPanelHolder.get(); } bool handleKey(KEY key, MASK mask); bool handleKeyUp(KEY key, MASK mask); void handleScrollWheel (S32 clicks); void handleScrollHWheel (S32 clicks); // add and remove views from "popup" layer void addPopup(LLView* popup); void removePopup(LLView* popup); void clearPopups(); // Hide normal UI when a logon fails, re-show everything when logon is attempted again void setNormalControlsVisible( bool visible ); void setMenuBackgroundColor(bool god_mode = false, bool dev_grid = false); void reshape(S32 width, S32 height); void sendShapeToSim(); void draw(); void updateDebugText(); void drawDebugText(); static void loadUserImage(void **cb_data, const LLUUID &uuid); static void movieSize(S32 new_width, S32 new_height); // snapshot functionality. // perhaps some of this should move to llfloatershapshot? -MG bool saveSnapshot(const std::string& filename, S32 image_width, S32 image_height, bool show_ui = true, bool show_hud = true, bool do_rebuild = false, LLSnapshotModel::ESnapshotLayerType type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR, LLSnapshotModel::ESnapshotFormat format = LLSnapshotModel::SNAPSHOT_FORMAT_BMP); bool rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_height, bool keep_window_aspect = true, bool is_texture = false, bool show_ui = true, bool show_hud = true, bool do_rebuild = false, bool no_post = false, LLSnapshotModel::ESnapshotLayerType type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR, S32 max_size = MAX_SNAPSHOT_IMAGE_SIZE); bool simpleSnapshot(LLImageRaw *raw, S32 image_width, S32 image_height, const int num_render_passes); // take a cubemap snapshot // origin - vantage point to take the snapshot from // cubearray - cubemap array for storing the results // index - cube index in the array to use (cube index, not face-layer) // face - which cube face to update // near_clip - near clip setting to use bool cubeSnapshot(const LLVector3 &origin, LLCubeMapArray *cubearray, S32 index, S32 face, F32 near_clip, bool render_avatars, bool customCullingPlane = false, LLPlane cullingPlane = LLPlane(LLVector3(0, 0, 0), LLVector3(0, 0, 1))); // special implementation of simpleSnapshot for reflection maps bool reflectionSnapshot(LLImageRaw* raw, S32 image_width, S32 image_height, const int num_render_passes); bool thumbnailSnapshot(LLImageRaw *raw, S32 preview_width, S32 preview_height, bool show_ui, bool show_hud, bool do_rebuild, bool no_post, LLSnapshotModel::ESnapshotLayerType type); bool isSnapshotLocSet() const; void resetSnapshotLoc() const; typedef boost::signals2::signal<void(void)> snapshot_saved_signal_t; void saveImageNumbered(LLImageFormatted *image, bool force_picker, const snapshot_saved_signal_t::slot_type& success_cb, const snapshot_saved_signal_t::slot_type& failure_cb); void onDirectorySelected(const std::vector<std::string>& filenames, LLImageFormatted *image, const snapshot_saved_signal_t::slot_type& success_cb, const snapshot_saved_signal_t::slot_type& failure_cb); void saveImageLocal(LLImageFormatted *image, const snapshot_saved_signal_t::slot_type& success_cb, const snapshot_saved_signal_t::slot_type& failure_cb); void onSelectionFailure(const snapshot_saved_signal_t::slot_type& failure_cb); // Reset the directory where snapshots are saved. // Client will open directory picker on next snapshot save. void resetSnapshotLoc(); void playSnapshotAnimAndSound(); // draws selection boxes around selected objects, must call displayObjects first void renderSelections( bool for_gl_pick, bool pick_parcel_walls, bool for_hud ); void performPick(); void returnEmptyPicks(); void pickAsync( S32 x, S32 y_from_bot, MASK mask, void (*callback)(const LLPickInfo& pick_info), bool pick_transparent = false, bool pick_rigged = false, bool pick_unselectable = false, bool pick_reflection_probes = false); LLPickInfo pickImmediate(S32 x, S32 y, bool pick_transparent, bool pick_rigged = false, bool pick_particle = false, bool pick_unselectable = true, bool pick_reflection_probe = false); LLHUDIcon* cursorIntersectIcon(S32 mouse_x, S32 mouse_y, F32 depth, LLVector4a* intersection); LLViewerObject* cursorIntersect(S32 mouse_x = -1, S32 mouse_y = -1, F32 depth = 512.f, LLViewerObject *this_object = NULL, S32 this_face = -1, bool pick_transparent = false, bool pick_rigged = false, bool pick_unselectable = true, bool pick_reflection_probe = true, S32* face_hit = NULL, S32* gltf_node_hit = nullptr, S32* gltf_primitive_hit = nullptr, LLVector4a *intersection = NULL, LLVector2 *uv = NULL, LLVector4a *normal = NULL, LLVector4a *tangent = NULL, LLVector4a* start = NULL, LLVector4a* end = NULL); // Returns a pointer to the last object hit //LLViewerObject *getObject(); //LLViewerObject *lastNonFloraObjectHit(); //const LLVector3d& getObjectOffset(); //const LLVector3d& lastNonFloraObjectHitOffset(); // mousePointOnLand() returns true if found point bool mousePointOnLandGlobal(const S32 x, const S32 y, LLVector3d *land_pos_global, bool ignore_distance = false); bool mousePointOnPlaneGlobal(LLVector3d& point, const S32 x, const S32 y, const LLVector3d &plane_point, const LLVector3 &plane_normal); LLVector3d clickPointInWorldGlobal(const S32 x, const S32 y_from_bot, LLViewerObject* clicked_object) const; bool clickPointOnSurfaceGlobal(const S32 x, const S32 y, LLViewerObject *objectp, LLVector3d &point_global) const; // Prints window implementation details void dumpState(); // handle shutting down GL and bringing it back up void requestResolutionUpdate(); void checkSettings(); F32 getWorldViewAspectRatio() const; const LLVector2& getDisplayScale() const { return mDisplayScale; } void calcDisplayScale(); static LLRect calcScaledRect(const LLRect & rect, const LLVector2& display_scale); static std::string getLastSnapshotDir(); LLView* getFloaterSnapRegion() { return mFloaterSnapRegion; } LLPanel* getChicletContainer() { return mChicletContainer; } private: bool shouldShowToolTipFor(LLMouseHandler *mh); void switchToolByMask(MASK mask); void destroyWindow(); void drawMouselookInstructions(); void stopGL(); void restoreGL(const std::string& progress_message = LLStringUtil::null); void initFonts(F32 zoom_factor = 1.f); void schedulePick(LLPickInfo& pick_info); S32 getChatConsoleBottomPad(); // Vertical padding for child console rect, varied by bottom clutter LLRect getChatConsoleRect(); // Get optimal cosole rect. private: LLWindow* mWindow; // graphical window object bool mActive; bool mUIVisible; LLNotificationChannelPtr mSystemChannel; LLNotificationChannelPtr mCommunicationChannel; LLNotificationChannelPtr mAlertsChannel; LLNotificationChannelPtr mModalAlertsChannel; LLRect mWindowRectRaw; // whole window, including UI LLRect mWindowRectScaled; // whole window, scaled by UI size LLRect mWorldViewRectRaw; // area of screen for 3D world LLRect mWorldViewRectScaled; // area of screen for 3D world scaled by UI size LLRootView* mRootView; // a view of size mWindowRectRaw, containing all child views LLView* mFloaterSnapRegion = nullptr; LLView* mNavBarContainer = nullptr; LLPanel* mStatusBarContainer = nullptr; LLPanel* mChicletContainer = nullptr; LLPanel* mTopInfoContainer = nullptr; LLVector2 mDisplayScale; LLCoordGL mCurrentMousePoint; // last mouse position in GL coords LLCoordGL mLastMousePoint; // Mouse point at last frame. LLCoordGL mCurrentMouseDelta; //amount mouse moved this frame bool mLeftMouseDown; bool mMiddleMouseDown; bool mRightMouseDown; LLProgressView *mProgressView; LLFrameTimer mToolTipFadeTimer; LLPanel* mToolTip; std::string mLastToolTipMessage; LLRect mToolTipStickyRect; // Once a tool tip is shown, it will stay visible until the mouse leaves this rect. bool mMouseInWindow; // True if the mouse is over our window or if we have captured the mouse. bool mFocusCycleMode; bool mAllowMouseDragging; LLFrameTimer mMouseDownTimer; typedef std::set<LLHandle<LLView> > view_handle_set_t; view_handle_set_t mMouseHoverViews; // Variables used for tool override switching based on modifier keys. JC MASK mLastMask; // used to detect changes in modifier mask LLTool* mToolStored; // the tool we're overriding bool mHideCursorPermanent; // true during drags, mouselook bool mCursorHidden; LLPickInfo mLastPick; std::vector<LLPickInfo> mPicks; LLRect mPickScreenRegion; // area of frame buffer for rendering pick frames (generally follows mouse to avoid going offscreen) LLTimer mPickTimer; // timer for scheduling n picks per second std::string mOverlayTitle; // Used for special titles such as "Second Life - Special E3 2003 Beta" std::string mInitAlert; // Window / GL initialization requires an alert LLHandle<LLView> mWorldViewPlaceholder; // widget that spans the portion of screen dedicated to rendering the 3d world LLHandle<LLView> mToolBarHolder; // container for toolbars LLHandle<LLView> mHintHolder; // container for hints LLHandle<LLView> mLoginPanelHolder; // container for login panel LLPopupView* mPopupView; // container for transient popups class LLDebugText* mDebugText; // Internal class for debug text bool mResDirty; bool mStatesDirty; std::unique_ptr<LLWindowListener> mWindowListener; std::unique_ptr<LLViewerWindowListener> mViewerWindowListener; // Object temporarily hovered over while dragging LLPointer<LLViewerObject> mDragHoveredObject; static LLTrace::SampleStatHandle<> sMouseVelocityStat; }; // // Globals // extern LLViewerWindow* gViewerWindow; extern LLFrameTimer gAwayTimer; // tracks time before setting the avatar away state to true extern LLFrameTimer gAwayTriggerTimer; // how long the avatar has been away extern LLViewerObject* gDebugRaycastObject; extern LLVector4a gDebugRaycastIntersection; extern LLVOPartGroup* gDebugRaycastParticle; extern LLVector4a gDebugRaycastParticleIntersection; extern LLVector2 gDebugRaycastTexCoord; extern LLVector4a gDebugRaycastNormal; extern LLVector4a gDebugRaycastTangent; extern S32 gDebugRaycastFaceHit; extern LLVector4a gDebugRaycastStart; extern LLVector4a gDebugRaycastEnd; extern bool gDisplayCameraPos; extern bool gDisplayWindInfo; extern bool gDisplayFOV; extern bool gDisplayBadge; #endif