OpenToonz - An open-source full-featured 2D animation creation software
C
increase 3D viewer scale.
JPUser1903b85d7dabc
diff --git a/toonz/sources/toonz/sceneviewer.cpp b/toonz/sources/toonz/sceneviewer.cppindex b6401334f..4826fbd11 100644--- a/toonz/sources/toonz/sceneviewer.cpp+++ b/toonz/sources/toonz/sceneviewer.cpp@@ -805,7 +805,7 @@ SceneViewer::SceneViewer(ImageUtils::FullScreenWidget *parent), m_viewMode(SCENE_VIEWMODE), m_pos(0, 0), m_pan3D(TPointD(0, 0))- , m_zoomScale3D(0.1)+ , m_zoomScale3D(1.0), m_theta3D(20), m_phi3D(30), m_dpiScale(TPointD(1, 1))@@ -2990,12 +2990,13 @@ void SceneViewer::resetSceneViewer() {m_pos = QPoint(0, 0);m_pan3D = TPointD(0, 0);- m_zoomScale3D = 0.1;+m_theta3D = 20;m_phi3D = 30;m_isFlippedX = false;m_isFlippedY = false;fitToCameraOutline();+ m_zoomScale3D = 1.0;emit onZoomChanged();emit onFlipHChanged(m_isFlippedX);emit onFlipVChanged(m_isFlippedY);@@ -3082,7 +3083,7 @@ void SceneViewer::setActualPixelSize() {m_pos = QPoint(0, 0);m_pan3D = TPointD(0, 0);- m_zoomScale3D = 0.1;+ m_zoomScale3D = 1.0;m_theta3D = 20;m_phi3D = 30;emit onZoomChanged();diff --git a/toonz/sources/toonz/sceneviewer.cpp.bak b/toonz/sources/toonz/sceneviewer.cpp.baknew file mode 100644index 000000000..b6401334f--- /dev/null+++ b/toonz/sources/toonz/sceneviewer.cpp.bak@@ -0,0 +1,3606 @@++#if defined(LINUX) || defined(FREEBSD) || defined(HAIKU)+#define GL_GLEXT_PROTOTYPES+#endif++// Toonz includes+#include "tapp.h"+#include "viewerpane.h"+#include "onionskinmaskgui.h"+#include "viewerdraw.h"+#include "menubarcommandids.h"+#include "ruler.h"+#include "locatorpopup.h"+#if defined(x64)+#include "../stopmotion/stopmotion.h"+#endif+#include "tenv.h"+#include "cellselection.h"++// TnzTools includes+#include "tools/cursors.h"+#include "tools/cursormanager.h"+#include "tools/toolhandle.h"+#include "tools/toolcommandids.h"+#include "tools/toolutils.h"+#include "tools/assistant.h"+#include "tools/replicator.h"++// TnzQt includes+#include "toonzqt/icongenerator.h"+#include "toonzqt/gutil.h"+#include "toonzqt/imageutils.h"+#include "toonzqt/lutcalibrator.h"+#include "toonzqt/viewcommandids.h"++// TnzLib includes+#include "toonz/tscenehandle.h"+#include "toonz/txsheethandle.h"+#include "toonz/tframehandle.h"+#include "toonz/tcolumnhandle.h"+#include "toonz/txshlevelhandle.h"+#include "toonz/sceneproperties.h"+#include "toonz/toonzscene.h"+#include "toonz/levelset.h"+#include "toonz/txshsimplelevel.h"+#include "toonz/tcamera.h"+#include "toonz/stage2.h"+#include "toonz/stage.h"+#include "toonz/stageplayer.h"+#include "toonz/stagevisitor.h"+#include "toonz/txsheet.h"+#include "toonz/tstageobjecttree.h"+#include "toonz/tstageobjectspline.h"+#include "toonz/tobjecthandle.h"+#include "toonz/tonionskinmaskhandle.h"+#include "toonz/palettecontroller.h"+#include "toonz/tpalettehandle.h"+#include "toonz/childstack.h"+#include "toonz/dpiscale.h"+#include "toonz/txshlevel.h"+#include "toonz/txshlevelcolumn.h"+#include "toonz/preferences.h"+#include "toonz/glrasterpainter.h"+#include "toonz/cleanupparameters.h"+#include "toonz/toonzimageutils.h"+#include "toonz/txshleveltypes.h"+#include "subcameramanager.h"+#include "toutputproperties.h"++// TnzCore includes+#include "tpalette.h"+#include "tropcm.h"+#include "tgl.h"+#include "tofflinegl.h"+#include "tstopwatch.h"+#include "trop.h"+#include "tproperty.h"+#include "timagecache.h"+#include "trasterimage.h"+#include "tstroke.h"+#include "ttoonzimage.h"+#include "tenv.h"++// Qt includes+#include <QMenu>+#include <QApplication>+#include <QScreen>+#include <QInputMethod>+#include <QGLContext>+#include <QOpenGLFramebufferObject>+#include <QMainWindow>++#include "sceneviewer.h"++TEnv::IntVar RotateOnCameraCenter("RotateOnCameraCenter", 0);+TEnv::DoubleVar RotateAngle("RotateAngle", 90);++void drawSpline(const TAffine &viewMatrix, const TRect &clipRect, bool camera3d,+ double pixelSize);++// 0: current frame+// 1: all frames in the preview range+// 2: selected cell, auto play once & stop+TEnv::IntVar EnvViewerPreviewBehavior("ViewerPreviewBehavior", 0);++//-------------------------------------------------------------------------------+namespace {++int l_mainDisplayListsSpaceId =+ -1; //!< Display lists space id associated with SceneViewers+std::set<TGlContext>+ l_contexts; //!< Stores every SceneViewer context (see ~SceneViewer)++//-------------------------------------------------------------------------------++struct DummyProxy : public TGLDisplayListsProxy {+ ~DummyProxy() {}+ void makeCurrent() {}+ void doneCurrent() {}+};++//-------------------------------------------------------------------------------++double getActualFrameRate() {+ // compute frame per second+ static double fps = 0;+ static TStopWatch stopwatch;+ static int frame = 0;+ ++frame;++ stopwatch.start();++ unsigned long tt = stopwatch.getTotalTime();++ // wait a time greater than one second+ if (tt > 1000) {+ stopwatch.stop();+ fps = troundp(((1000 * frame) / (double)tt));+ stopwatch.start(true);+ frame = 0;+ }+ return fps;+}++//-----------------------------------------------------------------------------++void copyFrontBufferToBackBuffer() {+ static GLint viewport[4];+ static GLfloat raster_pos[4];++ glGetIntegerv(GL_VIEWPORT, viewport);++ /* set source buffer */+ glReadBuffer(GL_FRONT);++ /* set projection matrix */+ glMatrixMode(GL_PROJECTION);+ glPushMatrix();+ glLoadIdentity();+ gluOrtho2D(0, viewport[2], 0, viewport[3]);++ /* set modelview matrix */+ glMatrixMode(GL_MODELVIEW);+ glPushMatrix();+ glLoadIdentity();++ /* save old raster position */+ glGetFloatv(GL_CURRENT_RASTER_POSITION, raster_pos);++ /* set raster position */+ glRasterPos4f(0.0, 0.0, 0.0, 1.0);++ /* copy buffer */+ glCopyPixels(0, 0, viewport[2], viewport[3], GL_COLOR);++ /* restore old raster position */+ glRasterPos4fv(raster_pos);++ /* restore old matrices */+ glPopMatrix();+ glMatrixMode(GL_PROJECTION);+ glPopMatrix();+ glMatrixMode(GL_MODELVIEW);++ /* restore source buffer */+ glReadBuffer(GL_BACK);+}+//-----------------------------------------------------------------------------+/*! Compute new 3Dposition and new 2D position. */+T3DPointD computeNew3DPosition(T3DPointD start3DPos, TPointD delta2D,+ TPointD &new2dPos, GLdouble modelView3D[16],+ GLdouble projection3D[16], GLint viewport3D[4],+ int devPixRatio) {+ GLdouble pos2D_x, pos2D_y, pos2D_z;+ gluProject(-start3DPos.x, -start3DPos.y, start3DPos.z, modelView3D,+ projection3D, viewport3D, &pos2D_x, &pos2D_y, &pos2D_z);+ new2dPos = TPointD(pos2D_x + delta2D.x, pos2D_y + delta2D.y);+ GLdouble pos3D_x, pos3D_y, pos3D_z;+ gluUnProject(new2dPos.x, new2dPos.y, 1, modelView3D, projection3D, viewport3D,+ &pos3D_x, &pos3D_y, &pos3D_z);+ new2dPos.y = viewport3D[3] - new2dPos.y - 20 * devPixRatio;+ return T3DPointD(pos3D_x, pos3D_y, pos3D_z);+}++//-----------------------------------------------------------------------------+#ifdef DA_RIVEDERE++// Il metodo copia una porzione del BACK_BUFFER definita da rect nel+// FRONTE_BUFFER+// Attualmente si notano delle brutture intorno al rettangolo.+// Per il momento si lavora nel BACK_BUFFER e sicopia tutto il FRONT_BUFFER.+// Riattivando questo metodo bisogna ricordarsi di disattivare lo swapbuffer in+// GLInvalidateRect prima di+// fare updateGL() e riattivarlo immediatamernte dopo!+void copyBackBufferToFrontBuffer(const TRect &rect) {+ static GLint viewport[4];+ static GLfloat raster_pos[4];++ glGetIntegerv(GL_VIEWPORT, viewport);++ /* set source buffer */+ glReadBuffer(GL_BACK);+ glDrawBuffer(GL_FRONT);++ /* set projection matrix */+ glMatrixMode(GL_PROJECTION);+ glPushMatrix();+ glLoadIdentity();+ gluOrtho2D(0, viewport[2], 0, viewport[3]);++ /* set modelview matrix */+ glMatrixMode(GL_MODELVIEW);+ glPushMatrix();+ glLoadIdentity();++ /* save old raster position */+ glGetFloatv(GL_CURRENT_RASTER_POSITION, raster_pos);++ /* set raster position */+ glRasterPos4f(0.0, 0.0, 0.0, 1.0);++ /* copy buffer */+ glCopyPixels(0, 0, viewport[2], viewport[3], GL_COLOR);++ /* restore old raster position */+ glRasterPos4fv(raster_pos);++ /* restore old matrices */+ glPopMatrix();+ glMatrixMode(GL_PROJECTION);+ glPopMatrix();+ glMatrixMode(GL_MODELVIEW);++ /* restore source buffer */+ glDrawBuffer(GL_BACK);+}++#endif++const TRectD InvalidateAllRect(0, 0, -1, -1);++//-----------------------------------------------------------------------------+} // namespace+//-----------------------------------------------------------------------------++//=============================================================================+// ToggleCommand+//-----------------------------------------------------------------------------++ToggleCommandHandler::ToggleCommandHandler(CommandId id, bool startStatus)+ : MenuItemHandler(id), m_status(startStatus) {}++void ToggleCommandHandler::execute() {+ m_status = !m_status;+ // emit sceneChanged WITHOUT dirty flag+ TApp::instance()->getCurrentScene()->notifySceneChanged(false);+}++//-----------------------------------------------------------------------------++ToggleCommandHandler viewTableToggle(MI_ViewTable, false);+ToggleCommandHandler editInPlaceToggle(MI_ToggleEditInPlace, false);+ToggleCommandHandler fieldGuideToggle(MI_FieldGuide, false);+ToggleCommandHandler safeAreaToggle(MI_SafeArea, false);+ToggleCommandHandler rasterizePliToggle(MI_RasterizePli, false);++ToggleCommandHandler viewClcToggle("MI_ViewColorcard", false);+ToggleCommandHandler viewCameraToggle("MI_ViewCamera", false);+ToggleCommandHandler viewBBoxToggle("MI_ViewBBox", false);+ToggleCommandHandler viewGuideToggle("MI_ViewGuide", false);+ToggleCommandHandler viewRulerToggle("MI_ViewRuler", false);++//-----------------------------------------------------------------------------++void invalidateIcons() {+ ToonzCheck *tc = ToonzCheck::instance();+ int mask = tc->getChecks();+ IconGenerator::Settings s;+ s.m_blackBgCheck = mask & ToonzCheck::eBlackBg;+ s.m_transparencyCheck = mask & ToonzCheck::eTransparency;+ s.m_inksOnly = mask & ToonzCheck::eInksOnly;+ // emphasize lines with style#1 regardless of the current style+ if (mask & ToonzCheck::eInk1) s.m_inkIndex = 1;+ // emphasize lines with the current style+ else if (mask & ToonzCheck::eInk)+ s.m_inkIndex = tc->getColorIndex();+ else+ s.m_inkIndex = -1;+ s.m_paintIndex = mask & ToonzCheck::ePaint ? tc->getColorIndex() : -1;+ IconGenerator::instance()->setSettings(s);++ // Force icons to refresh for Toonz Vector levels+ TXshLevel *sl = TApp::instance()->getCurrentLevel()->getLevel();+ if (sl && sl->getType() == PLI_XSHLEVEL) {+ std::vector<TFrameId> fids;+ sl->getFids(fids);++ for (int i = 0; i < (int)fids.size(); i++)+ IconGenerator::instance()->invalidate(sl, fids[i]);+ }++ // Do not remove icons here as they will be re-used for updating icons in the+ // level strip++ // emit sceneChanged WITHOUT dirty flag+ TApp::instance()->getCurrentScene()->notifySceneChanged(false);+ TApp::instance()->getCurrentLevel()->notifyLevelViewChange();+}++//--------------------------------------------------------------++static void executeCheck(int checkType) {+ ToonzCheck::instance()->toggleCheck(checkType);+ invalidateIcons();+}++//-----------------------------------------------------------------------------++class TCheckToggleCommand final : public MenuItemHandler {+public:+ TCheckToggleCommand() : MenuItemHandler("MI_TCheck") {}+ void execute() override { executeCheck(ToonzCheck::eTransparency); }+} tcheckToggle;++//-----------------------------------------------------------------------------++class ICheckToggleCommand final : public MenuItemHandler {+public:+ ICheckToggleCommand() : MenuItemHandler("MI_ICheck") {}+ void execute() override { executeCheck(ToonzCheck::eInk); }+} icheckToggle;++//-----------------------------------------------------------------------------++class PCheckToggleCommand final : public MenuItemHandler {+public:+ PCheckToggleCommand() : MenuItemHandler("MI_PCheck") {}+ void execute() override { executeCheck(ToonzCheck::ePaint); }+} pcheckToggle;++//-----------------------------------------------------------------------------++class BCheckToggleCommand final : public MenuItemHandler {+public:+ BCheckToggleCommand() : MenuItemHandler("MI_BCheck") {}+ void execute() override { executeCheck(ToonzCheck::eBlackBg); }+} bcheckToggle;++//-----------------------------------------------------------------------------++class TAutocloseToggleCommand final : public MenuItemHandler {+public:+ TAutocloseToggleCommand() : MenuItemHandler("MI_ACheck") {}+ void execute() override { executeCheck(ToonzCheck::eAutoclose); }+} tautocloseToggle;++//-----------------------------------------------------------------------------++class TGapToggleCommand final : public MenuItemHandler {+public:+ TGapToggleCommand() : MenuItemHandler("MI_GCheck") {}+ void execute() override { executeCheck(ToonzCheck::eGap); }+} tgapToggle;++//-----------------------------------------------------------------------------++class TInksOnlyToggleCommand final : public MenuItemHandler {+public:+ TInksOnlyToggleCommand() : MenuItemHandler("MI_IOnly") {}+ void execute() override { executeCheck(ToonzCheck::eInksOnly); }+} tinksOnlyToggle;++//-----------------------------------------------------------------------------+/*! emphasize lines with style#1 regardless of the current style+ */+class Ink1CheckToggleCommand final : public MenuItemHandler {+public:+ Ink1CheckToggleCommand() : MenuItemHandler("MI_Ink1Check") {}+ void execute() override { executeCheck(ToonzCheck::eInk1); }+} ink1checkToggle;++//=============================================================================++class TShiftTraceToggleCommand final : public MenuItemHandler {+ CommandId m_cmdId;++public:+ TShiftTraceToggleCommand(CommandId cmdId)+ : MenuItemHandler(cmdId), m_cmdId(cmdId) {}+ void execute() override {+ CommandManager *cm = CommandManager::instance();+ QAction *action = cm->getAction(m_cmdId);+ bool checked = action->isChecked();+ if (std::string(m_cmdId) == MI_ShiftTrace) {+ cm->enable(MI_EditShift, checked);+ cm->enable(MI_NoShift, checked);+ cm->enable(MI_ShowShiftOrigin, checked);+ if (checked) {+ OnioniSkinMaskGUI::resetShiftTraceFrameOffset();+ // activate edit shift+ if (isChecked(MI_EditShift))+ TApp::instance()->getCurrentTool()->setPseudoTool("T_ShiftTrace");+ } else {+ // deactivate edit shift+ if (isChecked(MI_EditShift))+ TApp::instance()->getCurrentTool()->unsetPseudoTool();+ }++ // cm->getAction(MI_NoShift)->setChecked(false);+ TApp::instance()->getCurrentOnionSkin()->notifyOnionSkinMaskChanged();+ } else if (std::string(m_cmdId) == MI_EditShift) {+ if (checked) {+ QAction *noShiftAction =+ CommandManager::instance()->getAction(MI_NoShift);+ if (noShiftAction) noShiftAction->setChecked(false);+ TApp::instance()->getCurrentTool()->setPseudoTool("T_ShiftTrace");+ } else {+ TApp::instance()->getCurrentTool()->unsetPseudoTool();+ }+ CommandManager::instance()->enable(MI_NoShift, !checked);+ } else if (std::string(m_cmdId) == MI_NoShift) {+ }+ updateShiftTraceStatus();+ }++ bool isChecked(CommandId id) const {+ QAction *action = CommandManager::instance()->getAction(id);+ return action != 0 && action->isChecked();+ }+ void updateShiftTraceStatus() {+ OnionSkinMask::ShiftTraceStatus status = OnionSkinMask::DISABLED;+ if (isChecked(MI_ShiftTrace)) {+ if (isChecked(MI_EditShift))+ status = OnionSkinMask::EDITING_GHOST;+ else if (isChecked(MI_NoShift))+ status = OnionSkinMask::ENABLED_WITHOUT_GHOST_MOVEMENTS;+ else+ status = OnionSkinMask::ENABLED;+ }+ OnionSkinMask osm =+ TApp::instance()->getCurrentOnionSkin()->getOnionSkinMask();+ osm.setShiftTraceStatus(status);+ osm.setShowShiftOrigin(isChecked(MI_ShowShiftOrigin));+ osm.clearGhostFlipKey();+ TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();+ TApp::instance()->getCurrentOnionSkin()->setOnionSkinMask(osm);+ }+};++TShiftTraceToggleCommand shiftTraceToggleCommand(MI_ShiftTrace),+ editShiftToggleCommand(MI_EditShift), noShiftToggleCommand(MI_NoShift),+ showShiftOriginCommand(MI_ShowShiftOrigin);++class TResetShiftTraceCommand final : public MenuItemHandler {+public:+ TResetShiftTraceCommand() : MenuItemHandler(MI_ResetShift) {}+ void execute() override {+ OnionSkinMask osm =+ TApp::instance()->getCurrentOnionSkin()->getOnionSkinMask();+ osm.setShiftTraceGhostCenter(0, TPointD());+ osm.setShiftTraceGhostCenter(1, TPointD());+ osm.setShiftTraceGhostAff(0, TAffine());+ osm.setShiftTraceGhostAff(1, TAffine());+ TApp::instance()->getCurrentOnionSkin()->setOnionSkinMask(osm);+ TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool) tool->reset();+ }+} resetShiftTraceCommand;++//-----------------------------------------------------------------------------+// Following commands (VB_***) are registered for command bar buttons.+// They are separatd from the original visalization commands+// so that they will not break a logic of ShortcutZoomer.++class TViewResetCommand final : public MenuItemHandler {+public:+ TViewResetCommand() : MenuItemHandler(VB_ViewReset) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->resetSceneViewer();+ }+} viewResetCommand;++class TZoomResetCommand final : public MenuItemHandler {+public:+ TZoomResetCommand() : MenuItemHandler(VB_ZoomReset) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->resetZoom();+ }+} zoomResetCommand;++class TZoomFitCommand final : public MenuItemHandler {+public:+ TZoomFitCommand() : MenuItemHandler(VB_ZoomFit) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->fitToCamera();+ }+} zoomFitCommand;++class TActualPixelSizeCommand final : public MenuItemHandler {+public:+ TActualPixelSizeCommand() : MenuItemHandler(VB_ActualPixelSize) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->setActualPixelSize();+ }+} actualPixelSizeCommand;++class TFlipViewerXCommand final : public MenuItemHandler {+public:+ TFlipViewerXCommand() : MenuItemHandler(VB_FlipX) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->flipX();+ }+} flipViewerXCommand;++class TFlipViewerYCommand final : public MenuItemHandler {+public:+ TFlipViewerYCommand() : MenuItemHandler(VB_FlipY) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->flipY();+ }+} flipViewerYCommand;++class TRotateViewerLeftCommand final : public MenuItemHandler {+public:+ TRotateViewerLeftCommand() : MenuItemHandler(VB_RotateLeft) {}+ void execute() override {+ SceneViewer *viewer = TApp::instance()->getActiveViewer();+ if (viewer) {+ viewer->rotateLeft();+ }+ }+} rotateViewerLeftCommand;++class TRotateViewerRightCommand final : public MenuItemHandler {+public:+ TRotateViewerRightCommand() : MenuItemHandler(VB_RotateRight) {}+ void execute() override {+ SceneViewer *viewer = TApp::instance()->getActiveViewer();+ if (viewer) {+ viewer->rotateRight();+ }+ }+} rotateViewerRightCommand;++class TRotateResetCommand final : public MenuItemHandler {+public:+ TRotateResetCommand() : MenuItemHandler(VB_RotateReset) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->resetRotation();+ }+} rotateResetCommand;++class TPositionResetCommand final : public MenuItemHandler {+public:+ TPositionResetCommand() : MenuItemHandler(VB_PositionReset) {}+ void execute() override {+ if (TApp::instance()->getActiveViewer())+ TApp::instance()->getActiveViewer()->resetPosition();+ }+} positionResetCommand;++class TVectorGuidedDrawingToggleCommand final : public MenuItemHandler {+public:+ TVectorGuidedDrawingToggleCommand()+ : MenuItemHandler(MI_VectorGuidedDrawing) {}+ void execute() override {+ CommandManager *cm = CommandManager::instance();+ QAction *action = cm->getAction(MI_VectorGuidedDrawing);+ Preferences::instance()->setValue(guidedDrawingType,+ action->isChecked() ? 1 : 0);+ TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();+ TApp::instance()->getCurrentScene()->notifyPreferenceChanged(+ "GuidedDrawingFrame");+ }++ bool isChecked(CommandId id) const {+ QAction *action = CommandManager::instance()->getAction(id);+ return action != 0 && action->isChecked();+ }+} vectorGuidedDrawingToggleCommand;++class TSelectGuideStrokeResetCommand final : public MenuItemHandler {+public:+ TSelectGuideStrokeResetCommand()+ : MenuItemHandler(MI_SelectGuideStrokeReset) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->getViewer()->setGuidedStrokePickerMode(0);+ tool->getViewer()->setGuidedBackStroke(-1);+ tool->getViewer()->setGuidedFrontStroke(-1);+ tool->getViewer()->invalidateAll();+ }+} SelectGuideStrokeResetCommand;++class TSelectGuideStrokeNextCommand final : public MenuItemHandler {+public:+ TSelectGuideStrokeNextCommand() : MenuItemHandler(MI_SelectNextGuideStroke) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->getViewer()->setGuidedStrokePickerMode(1);+ }+} selectGuideStrokeNextCommand;++class TSelectGuideStrokePrevCommand final : public MenuItemHandler {+public:+ TSelectGuideStrokePrevCommand() : MenuItemHandler(MI_SelectPrevGuideStroke) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->getViewer()->setGuidedStrokePickerMode(-1);+ }+} selectGuideStrokePrevCommand;++class TSelectBothGuideStrokesCommand final : public MenuItemHandler {+public:+ TSelectBothGuideStrokesCommand()+ : MenuItemHandler(MI_SelectBothGuideStrokes) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->getViewer()->setGuidedStrokePickerMode(-2);+ }+} selectBothGuideStrokesCommand;++class TTweenGuideStrokesCommand final : public MenuItemHandler {+public:+ TTweenGuideStrokesCommand() : MenuItemHandler(MI_TweenGuideStrokes) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->tweenSelectedGuideStrokes();+ }+} tweenGuideStrokesCommand;++class TTweenGuideStrokeToSelectedCommand final : public MenuItemHandler {+public:+ TTweenGuideStrokeToSelectedCommand()+ : MenuItemHandler(MI_TweenGuideStrokeToSelected) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->tweenGuideStrokeToSelected();+ }+} tweenGuideStrokeToSelectedCommand;++class TSelectGuidesAndTweenCommand final : public MenuItemHandler {+public:+ TSelectGuidesAndTweenCommand()+ : MenuItemHandler(MI_SelectGuidesAndTweenMode) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->getViewer()->setGuidedStrokePickerMode(-3);+ }+} selectGuidesAndTweenCommand;++class TFlipNextStrokeDirectionCommand final : public MenuItemHandler {+public:+ TFlipNextStrokeDirectionCommand() : MenuItemHandler(MI_FlipNextGuideStroke) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->flipGuideStrokeDirection(1);+ }+} flipNextStrokeDirectionCommand;++class TFlipPrevStrokeDirectionCommand final : public MenuItemHandler {+public:+ TFlipPrevStrokeDirectionCommand() : MenuItemHandler(MI_FlipPrevGuideStroke) {}+ void execute() override {+ TVectorImageP vi = (TVectorImageP)TTool::getImage(false);+ if (!vi) return;++ Preferences *pref = Preferences::instance();+ if (!pref->isOnionSkinEnabled() || (pref->getGuidedDrawingType() != 1 &&+ pref->getGuidedDrawingType() != 2))+ return;++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (!tool) return;++ tool->flipGuideStrokeDirection(-1);+ }+} flipPrevStrokeDirectionCommand;++//=============================================================================+// SceneViewer+//-----------------------------------------------------------------------------++SceneViewer::SceneViewer(ImageUtils::FullScreenWidget *parent)+ : TToolViewer(this, parent)+ , m_pressure(0)+ , m_lastMousePos(0, 0)+ , m_mouseButton(Qt::NoButton)+ , m_foregroundDrawing(false)+ , m_tabletEvent(false)+ , m_tabletMove(false)+ , m_buttonClicked(false)+ , m_referenceMode(NORMAL_REFERENCE)+ , m_previewMode(NO_PREVIEW)+ , m_isMouseEntered(false)+ , m_forceGlFlush(true)+ , m_freezedStatus(NO_FREEZED)+ , m_viewGrabImage(0)+ , m_FPS(0)+ , m_hRuler(0)+ , m_vRuler(0)+ , m_viewMode(SCENE_VIEWMODE)+ , m_pos(0, 0)+ , m_pan3D(TPointD(0, 0))+ , m_zoomScale3D(0.1)+ , m_theta3D(20)+ , m_phi3D(30)+ , m_dpiScale(TPointD(1, 1))+ , m_compareSettings()+ , m_minZ(0)+ , m_tableDLId(-1)+ , m_groupIndexToBeEntered(-1)+ , m_pixelSize(1)+ , m_eraserPointerOn(false)+ , m_backupTool("")+ , m_clipRect()+ , m_isPicking(false)+ , m_current3DDevice(NONE)+ , m_sideRasterPos()+ , m_topRasterPos()+ , m_toolDisableReason("")+ , m_editPreviewSubCamera(false)+ , m_isLocator(false)+ , m_isBusyOnTabletMove(false) {+ m_visualSettings.m_sceneProperties =+ TApp::instance()->getCurrentScene()->getScene()->getProperties();+#if defined(x64)+ m_stopMotion = StopMotion::instance();+#endif+ // Enables multiple key input.+ setAttribute(Qt::WA_KeyCompression);+ // Enables input methods for Asian languages.+ setAttribute(Qt::WA_InputMethodEnabled);+ setFocusPolicy(Qt::StrongFocus);+ setAcceptDrops(true);+ this->setMouseTracking(true);+ // introduced from Qt 5.9+ this->setTabletTracking(true);++ for (int i = 0; i < m_viewAff.size(); ++i) {+ setViewMatrix(getNormalZoomScale(), i);+ m_rotationAngle[i] = 0.0;+ }++ m_3DSideR = rasterFromQPixmap(svgToPixmap(":Resources/3Dside_r.svg"));+ m_3DSideL = rasterFromQPixmap(svgToPixmap(":Resources/3Dside_l.svg"));+ m_3DTop = rasterFromQPixmap(svgToPixmap(":Resources/3Dtop.svg"));++ setAttribute(Qt::WA_AcceptTouchEvents);+ grabGesture(Qt::SwipeGesture);+ grabGesture(Qt::PanGesture);+ grabGesture(Qt::PinchGesture);++ setUpdateBehavior(QOpenGLWidget::PartialUpdate);++ if (Preferences::instance()->isColorCalibrationEnabled())+ m_lutCalibrator = new LutCalibrator();+ if (Preferences::instance()->is30bitDisplayEnabled())+ setTextureFormat(TGL_TexFmt10);+}++//-----------------------------------------------------------------------------++void SceneViewer::setVisual(const ImagePainter::VisualSettings &settings) {+ // m_visualSettings.m_blankColor = settings.m_blankColor;//for the blank+ // frames, I don't have to repaint the viewer are using updateGl!+ bool repaint = m_visualSettings.needRepaint(settings);+ m_visualSettings = settings;+ m_visualSettings.m_sceneProperties =+ TApp::instance()->getCurrentScene()->getScene()->getProperties();+ if (repaint) GLInvalidateAll();+}++//-----------------------------------------------------------------------------++SceneViewer::~SceneViewer() {+ // notify FilmStripFrames and safely disconnect with this+ emit aboutToBeDestroyed();++ if (m_fbo) delete m_fbo;++ // release all the registered context (once when exit the software)+ std::set<TGlContext>::iterator ct, cEnd(l_contexts.end());+ for (ct = l_contexts.begin(); ct != cEnd; ++ct)+ TGLDisplayListsManager::instance()->releaseContext(*ct);+ l_contexts.clear();+}++//-------------------------------------------------------------------------------++// Builds the view area, in camera reference+TRectD SceneViewer::getPreviewRect() const {+ TApp *app = TApp::instance();+ int row = app->getCurrentFrame()->getFrame();+ TXsheet *xsh = app->getCurrentXsheet()->getXsheet();+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ double cameraZ = xsh->getZ(cameraId, row);+ TAffine cameraAff =+ xsh->getPlacement(cameraId, row) * TScale((1000 + cameraZ) / 1000);++ TDimensionD cameraSize =+ app->getCurrentScene()->getScene()->getCurrentCamera()->getSize();+ TDimension cameraRes =+ app->getCurrentScene()->getScene()->getCurrentCamera()->getRes();+ TScale cameraScale(Stage::inch * cameraSize.lx / cameraRes.lx,+ Stage::inch * cameraSize.ly / cameraRes.ly);++ TRectD viewRect(-width() * 0.5, -height() * 0.5, width() * 0.5,+ height() * 0.5);++ return (getViewMatrix() * cameraAff * cameraScale).inv() * viewRect;+}++//-------------------------------------------------------------------------------++void SceneViewer::onRenderStarted(int frame) { emit previewStatusChanged(); }++//-------------------------------------------------------------------------------++void SceneViewer::onRenderCompleted(int frame) {+ invalidateAll();+ emit previewStatusChanged();+}++//-------------------------------------------------------------------------------++void SceneViewer::onPreviewUpdate() {+ update();+ emit previewStatusChanged();+}++//-----------------------------------------------------------------------------++void SceneViewer::setReferenceMode(int referenceMode) {+ if (m_referenceMode == referenceMode) return;++ TApp *app = TApp::instance();+ if (app->getCurrentFrame()->isEditingLevel())+ app->getCurrentFrame()->setFrame(app->getCurrentFrame()->getFrame());+ if (m_freezedStatus != NO_FREEZED) {+ freeze(false);+ emit freezeStateChanged(false);+ }++ m_referenceMode = referenceMode;+ invalidateAll();+ emit onZoomChanged();+}++//-------------------------------------------------------------------------------++void SceneViewer::freeze(bool on) {+ if (!on) {+ m_viewGrabImage = TRaster32P();+ m_freezedStatus = NO_FREEZED;+ } else {+ setCursor(Qt::ForbiddenCursor);+ m_freezedStatus = UPDATE_FREEZED;+ }+ GLInvalidateAll();+}++//-------------------------------------------------------------------------------++void SceneViewer::enablePreview(int previewMode) {+ if (m_previewMode == previewMode) return;++ TApp *app = TApp::instance();+ if (app->getCurrentFrame()->isEditingLevel() && previewMode != NO_PREVIEW)+ app->getCurrentFrame()->setFrame(app->getCurrentFrame()->getFrame());++ if (m_freezedStatus != NO_FREEZED) {+ freeze(false);+ emit freezeStateChanged(false);+ }++ if (m_previewMode != NO_PREVIEW) {+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW)+ ->removeListener(this);+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW)+ ->clearAllUnfinishedFrames();+ }++ m_previewMode = previewMode;++ // Schedule as a listener to Previewer.+ if (m_previewMode != NO_PREVIEW) {+ Previewer *previewer =+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW);++ previewer->addListener(this);+ // 0: current frame+ // 1: all frames in the preview range+ // 2: selected cell, auto play once & stop+ if (EnvViewerPreviewBehavior == 1) {+ int r0, r1, step;+ ToonzScene *scene = app->getCurrentScene()->getScene();+ scene->getProperties()->getPreviewProperties()->getRange(r0, r1, step);+ if (r0 > r1) {+ r0 = 0;+ r1 = scene->getFrameCount() - 1;+ }+ int currentFrame = app->getCurrentFrame()->getFrame();+ std::vector<int> queueFrames;+ for (int f = currentFrame; f <= r1; f += step) queueFrames.push_back(f);+ for (int f = r0; f < currentFrame; f += step) queueFrames.push_back(f);++ previewer->addFramesToRenderQueue(queueFrames);+ } else if (EnvViewerPreviewBehavior == 2) {+ TCellSelection *cellSel =+ dynamic_cast<TCellSelection *>(TSelection::getCurrent());+ if (cellSel && !cellSel->isEmpty()) {+ int r0, c0, r1, c1;+ cellSel->getSelectedCells(r0, c0, r1, c1);+ if (r0 < r1) {+ std::vector<int> queueFrames;+ for (int f = r0; f <= r1; f++) queueFrames.push_back(f);+ previewer->addFramesToRenderQueue(queueFrames);+ }+ }+ }+ previewer->update();+ }++ GLInvalidateAll();++ // for updating the title bar+ emit previewToggled();+}++//-----------------------------------------------------------------------------++TPointD SceneViewer::winToWorld(const QPointF &pos) const {+ // coordinate window (origine in alto a sinistra) -> coordinate colonna+ // (origine al centro dell'immagine)+ TPointD pp(pos.x() - (double)width() / 2.0,+ -pos.y() + (double)height() / 2.0);+ if (is3DView()) {+ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ double z = xsh->getStageObject(cameraId)->getZ(+ TApp::instance()->getCurrentFrame()->getFrame());++ TPointD p(pp.x - m_pan3D.x, pp.y - m_pan3D.y);+ p = p * (1 / m_zoomScale3D);+ double theta = m_theta3D * M_PI_180;+ double phi = m_phi3D * M_PI_180;+ double cs_phi = cos(phi);+ double sn_phi = sin(phi);+ double cs_theta = cos(theta);+ double sn_theta = sin(theta);+ TPointD a(cs_phi, sn_theta * sn_phi); // proiezione di (1,0,0)+ TPointD b(0, cs_theta); // proiezione di (0,1,0)+ TPointD c(sn_phi, -sn_theta * cs_phi); // proiezione di (0,0,1)+ TPointD aa = rotate90(a);+ TPointD bb = rotate90(b);++ double abb = a * bb;+ double baa = b * aa;+ if (fabs(abb) > 0.001 && fabs(baa) > 0.001) {+ p -= c * z;+ TPointD g((p * bb) / (a * bb), (p * aa) / (b * aa));+ return TAffine() * g;+ } else+ return TAffine() * TPointD(0, 0);+ }++ return getViewMatrix().inv() * pp;+}++//-----------------------------------------------------------------------------++TPointD SceneViewer::winToWorld(const TPointD &winPos) const {+ return winToWorld(QPointF(winPos.x, height() - winPos.y));+}++//-----------------------------------------------------------------------------++TPointD SceneViewer::worldToPos(const TPointD &worldPos) const {+ TPointD p = getViewMatrix() * worldPos;+ return TPointD(width() / 2 + p.x, height() / 2 + p.y);+}++//-----------------------------------------------------------------------------++void SceneViewer::showEvent(QShowEvent *) {+ m_visualSettings.m_sceneProperties =+ TApp::instance()->getCurrentScene()->getScene()->getProperties();++ // If the viewer is hidden and preview is activated, remove the listener from+ // preview+ if (m_previewMode != NO_PREVIEW)+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW)->addListener(this);++ TApp *app = TApp::instance();++ TSceneHandle *sceneHandle = app->getCurrentScene();+ bool ret = connect(sceneHandle, SIGNAL(sceneSwitched()), this,+ SLOT(resetSceneViewer()));+ ret = ret && connect(sceneHandle, SIGNAL(sceneChanged()), this,+ SLOT(onSceneChanged()));+ ret = ret && connect(sceneHandle, SIGNAL(preferenceChanged(const QString &)),+ this, SLOT(onPreferenceChanged(const QString &)));++ TFrameHandle *frameHandle = app->getCurrentFrame();+ ret = ret && connect(frameHandle, SIGNAL(frameSwitched()), this,+ SLOT(onFrameSwitched()));++ TPaletteHandle *paletteHandle =+ app->getPaletteController()->getCurrentLevelPalette();+ ret = ret && connect(paletteHandle, SIGNAL(colorStyleChanged(bool)), this,+ SLOT(update()));++ ret = ret && connect(app->getCurrentObject(), SIGNAL(objectSwitched()), this,+ SLOT(onObjectSwitched()));+ ret = ret && connect(app->getCurrentObject(), SIGNAL(objectChanged(bool)),+ this, SLOT(update()));++ ret =+ ret && connect(app->getCurrentOnionSkin(), SIGNAL(onionSkinMaskChanged()),+ this, SLOT(onOnionSkinMaskChanged()));++ ret = ret && connect(app->getCurrentLevel(), SIGNAL(xshLevelChanged()), this,+ SLOT(update()));+ ret = ret && connect(app->getCurrentLevel(), SIGNAL(xshCanvasSizeChanged()),+ this, SLOT(update()));+ // when level is switched, update m_dpiScale in order to show white background+ // for Ink&Paint work properly+ ret = ret &&+ connect(app->getCurrentLevel(), SIGNAL(xshLevelSwitched(TXshLevel *)),+ this, SLOT(onLevelSwitched()));++ ret = ret && connect(app->getCurrentXsheet(), SIGNAL(xsheetChanged()), this,+ SLOT(onXsheetChanged()));+ ret = ret && connect(app->getCurrentXsheet(), SIGNAL(xsheetSwitched()), this,+ SLOT(update()));++ // update tooltip when tool options are changed+ ret = ret && connect(app->getCurrentTool(), SIGNAL(toolChanged()), this,+ SLOT(onToolChanged()));+ ret = ret && connect(app->getCurrentTool(), SIGNAL(toolCursorTypeChanged()),+ this, SLOT(onToolChanged()));++ ret = ret &&+ connect(app, SIGNAL(tabletLeft()), this, SLOT(resetTabletStatus()));+#if defined(x64)+ if (m_stopMotion) {+ ret = ret && connect(m_stopMotion, SIGNAL(newLiveViewImageReady()), this,+ SLOT(onNewStopMotionImageReady()));+ ret = ret && connect(m_stopMotion, SIGNAL(liveViewStopped()), this,+ SLOT(onStopMotionLiveViewStopped()));+ }+#endif+ assert(ret);++ if (m_hRuler && m_vRuler) {+ if (!viewRulerToggle.getStatus()) {+ m_hRuler->hide();+ m_vRuler->hide();+ } else {+ m_hRuler->show();+ m_vRuler->show();+ }+ }+ if (m_shownOnce == false) {+ fitToCamera();+ m_shownOnce = true;+ }+ TApp::instance()->setActiveViewer(this);++ onPreferenceChanged("ColorCalibration");+ update();+}++//-----------------------------------------------------------------------------++void SceneViewer::hideEvent(QHideEvent *) {+ // If the viewer is hidden and preview is activated, remove the listener from+ // preview+ if (m_previewMode != NO_PREVIEW)+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW)+ ->removeListener(this);++ TApp *app = TApp::instance();++ TSceneHandle *sceneHandle = app->getCurrentScene();+ if (sceneHandle) sceneHandle->disconnect(this);++ TFrameHandle *frameHandle = app->getCurrentFrame();+ if (frameHandle) frameHandle->disconnect(this);++ TPaletteHandle *paletteHandle =+ app->getPaletteController()->getCurrentLevelPalette();+ if (paletteHandle) paletteHandle->disconnect(this);++ TObjectHandle *objectHandle = app->getCurrentObject();+ if (objectHandle) objectHandle->disconnect(this);++ TOnionSkinMaskHandle *onionHandle = app->getCurrentOnionSkin();+ if (onionHandle) onionHandle->disconnect(this);++ TXshLevelHandle *levelHandle = app->getCurrentLevel();+ if (levelHandle) levelHandle->disconnect(this);++ TXsheetHandle *xsheetHandle = app->getCurrentXsheet();+ if (xsheetHandle) xsheetHandle->disconnect(this);++ ToolHandle *toolHandle = app->getCurrentTool();+ if (toolHandle) toolHandle->disconnect(this);++ disconnect(app, SIGNAL(tabletLeft()), this, SLOT(resetTabletStatus()));++#if defined(x64)+ if (m_stopMotion) {+ disconnect(m_stopMotion, SIGNAL(newImageReady()), this,+ SLOT(onNewStopMotionImageReady()));+ disconnect(m_stopMotion, SIGNAL(liveViewStopped()), this,+ SLOT(onStopMotionLiveViewStopped()));+ }+#endif+}++int SceneViewer::getVGuideCount() {+ if (viewGuideToggle.getStatus())+ return m_vRuler->getGuideCount();+ else+ return 0;+}+int SceneViewer::getHGuideCount() {+ if (viewGuideToggle.getStatus())+ return m_hRuler->getGuideCount();+ else+ return 0;+}++double SceneViewer::getVGuide(int index) { return m_vRuler->getGuide(index); }+double SceneViewer::getHGuide(int index) { return m_hRuler->getGuide(index); }++#if defined(x64)+//-----------------------------------------------------------------------------++void SceneViewer::onNewStopMotionImageReady() {+ if (m_stopMotion->m_hasLineUpImage) {+ // if (m_hasStopMotionLineUpImage) delete m_stopMotionLineUpImage;+ m_stopMotionLineUpImage =+ (TRasterImageP)m_stopMotion->m_lineUpImage->clone();+ m_stopMotionLineUpImage->setDpi(m_stopMotion->m_liveViewDpi.x,+ m_stopMotion->m_liveViewDpi.y);+ m_hasStopMotionLineUpImage = true;+ }+ if (m_stopMotion->m_hasLiveViewImage) {+ // if (m_hasStopMotionImage) delete m_stopMotionImage;+ m_stopMotionImage = m_stopMotion->m_liveViewImage->clone();+ m_stopMotionImage->setDpi(m_stopMotion->m_liveViewDpi.x,+ m_stopMotion->m_liveViewDpi.y);+ m_hasStopMotionImage = true;+ if (m_stopMotion->m_canon->m_pickLiveViewZoom) {+ setToolCursor(this, ToolCursor::ZoomCursor);+ }+ onSceneChanged();+ }+}++//-----------------------------------------------------------------------------++void SceneViewer::onStopMotionLiveViewStopped() {+ m_hasStopMotionImage = false;+ m_hasStopMotionLineUpImage = false;+ onSceneChanged();+}++#endif // x64+//-----------------------------------------------------------------------------++void SceneViewer::onPreferenceChanged(const QString &prefName) {+ if (prefName == "ColorCalibration") {+ if (Preferences::instance()->isColorCalibrationEnabled()) {+ // if the window is so shriked that the gl widget is empty,+ // showEvent can be called before creating the context.+ if (!context()) return;+ makeCurrent();+ if (!m_lutCalibrator)+ m_lutCalibrator = new LutCalibrator();+ else+ m_lutCalibrator->cleanup();+ m_lutCalibrator->initialize();+ connect(context(), SIGNAL(aboutToBeDestroyed()), this,+ SLOT(onContextAboutToBeDestroyed()));+ if (m_lutCalibrator->isValid() && !m_fbo) {+ if (Preferences::instance()->is30bitDisplayEnabled()) {+ QOpenGLFramebufferObjectFormat format;+ format.setInternalTextureFormat(TGL_TexFmt10);+ m_fbo = new QOpenGLFramebufferObject(width(), height(), format);+ } else // normally, initialize with GL_RGBA8 format+ m_fbo = new QOpenGLFramebufferObject(width(), height());+ }+ doneCurrent();+ }+ update();+ }+}++//-----------------------------------------------------------------------------+void SceneViewer::initializeGL() {+ initializeOpenGLFunctions();++ registerContext();++ // to be computed once through the software+ if (m_lutCalibrator && !m_lutCalibrator->isInitialized()) {+ m_lutCalibrator->initialize();+ connect(context(), SIGNAL(aboutToBeDestroyed()), this,+ SLOT(onContextAboutToBeDestroyed()));+ }++ // glClearColor(1.0,1.0,1.0,1);+ glClear(GL_COLOR_BUFFER_BIT);++ if (m_firstInitialized)+ m_firstInitialized = false;+ else {+ resizeGL(width(), height());+ update();+ }+ // re-computing the display list for the table+ m_tableDLId = -1;+}++//-----------------------------------------------------------------------------++void SceneViewer::resizeGL(int w, int h) {+ w *= getDevPixRatio();+ h *= getDevPixRatio();+ glViewport(0, 0, w, h);+ glMatrixMode(GL_PROJECTION);+ glLoadIdentity();+ glOrtho(0, w, 0, h, -4000, 4000);+ m_projectionMatrix.setToIdentity();+ m_projectionMatrix.ortho(0, w, 0, h, -4000, 4000);++ glMatrixMode(GL_MODELVIEW);+ glLoadIdentity();+ glTranslatef(0.375, 0.375, 0.0);+ // make the center of the viewer = origin+ glTranslated(w * 0.5, h * 0.5, 0);++ if (m_freezedStatus == NORMAL_FREEZED) m_freezedStatus = UPDATE_FREEZED;++ if (m_previewMode != NO_PREVIEW) requestTimedRefresh();++ // remake fbo with new size+ if (m_lutCalibrator && m_lutCalibrator->isValid()) {+ if (m_fbo) delete m_fbo;+ if (Preferences::instance()->is30bitDisplayEnabled()) {+ QOpenGLFramebufferObjectFormat format;+ format.setInternalTextureFormat(TGL_TexFmt10);+ m_fbo = new QOpenGLFramebufferObject(w, h, format);+ } else // normally, initialize with GL_RGBA8 format+ m_fbo = new QOpenGLFramebufferObject(w, h);+ }++ // for updating the navigator in levelstrip+ emit refreshNavi();+}++//-----------------------------------------------------------------------------++void SceneViewer::drawBuildVars() {+ TApp *app = TApp::instance();++ int frame = app->getCurrentFrame()->getFrame();+ TXsheet *xsh = app->getCurrentXsheet()->getXsheet();++ // Camera affine+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ TStageObject *camera = xsh->getStageObject(cameraId);+ TAffine cameraPlacement = camera->getPlacement(frame);+ double cameraZ = camera->getZ(frame);++ m_drawCameraAff =+ getViewMatrix() * cameraPlacement * TScale((1000 + cameraZ) / 1000);++ // Table affine+ TStageObject *table = xsh->getStageObject(TStageObjectId::TableId);+ TAffine tablePlacement = table->getPlacement(frame);+ double tableZ = table->getZ(frame);+ TAffine placement;++ m_drawIsTableVisible = TStageObject::perspective(+ placement, cameraPlacement, cameraZ, tablePlacement, tableZ, 0);+ m_drawTableAff = getViewMatrix() * tablePlacement;++ // Camera test check+ m_drawCameraTest = CameraTestCheck::instance()->isEnabled();++ if (m_previewMode == NO_PREVIEW) {+ m_drawEditingLevel = app->getCurrentFrame()->isEditingLevel();+ m_viewMode = m_drawEditingLevel ? LEVEL_VIEWMODE : SCENE_VIEWMODE;+ m_draw3DMode = is3DView() && (m_previewMode != SUBCAMERA_PREVIEW);+ } else {+ m_drawEditingLevel = false;+ m_viewMode = app->getCurrentFrame()->isEditingLevel();+ m_draw3DMode = false;+ }++ // Clip rect+ if (!m_clipRect.isEmpty() && !m_draw3DMode) {+ m_actualClipRect = getActualClipRect(getViewMatrix());+ m_actualClipRect += TPoint(width() * 0.5, height() * 0.5);+ }++ TTool *tool = app->getCurrentTool()->getTool();+ if (tool && !m_isLocator) tool->setViewer(this);+}++//-----------------------------------------------------------------------------++void SceneViewer::drawEnableScissor() {+ if (!m_clipRect.isEmpty() && !m_draw3DMode) {+ glEnable(GL_SCISSOR_TEST);+ glScissor(m_actualClipRect.x0, m_actualClipRect.y0,+ m_actualClipRect.getLx(), m_actualClipRect.getLy());+ }+}++//-----------------------------------------------------------------------------++void SceneViewer::drawDisableScissor() {+ if (!m_clipRect.isEmpty() && !m_draw3DMode) {+ glDisable(GL_SCISSOR_TEST);+ }+ // clear the clipping rect+ m_clipRect.empty();+}++//-----------------------------------------------------------------------------++void SceneViewer::drawBackground() {+ TApp *app = TApp::instance();+ ToonzScene *scene = app->getCurrentScene()->getScene();++ if (m_visualSettings.m_colorMask == 0) {+ TPixel32 bgColor;++ if (isPreviewEnabled())+ bgColor = Preferences::instance()->getPreviewBgColor();+ else+ bgColor = Preferences::instance()->getViewerBgColor();+ glClearColor(bgColor.r / 255.0f, bgColor.g / 255.0f, bgColor.b / 255.0f,+ 1.0);+ } else+ glClearColor(0, 0, 0, 1.0);++ glClear(GL_COLOR_BUFFER_BIT);+ if (glGetError() == GL_INVALID_FRAMEBUFFER_OPERATION) {+ /* 起動時一回目になぜか GL_FRAMEBUFFER_COMPLETE なのに invalid operation+ * が出る */+ GLenum status = 0;+#ifdef _WIN32+ PROC proc = wglGetProcAddress("glCheckFramebufferStatusEXT");+ if (proc != nullptr)+ status = reinterpret_cast<PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC>(proc)(+ GL_FRAMEBUFFER);+#else+ status = glCheckFramebufferStatus(GL_FRAMEBUFFER);+#endif+ printf("GL_INVALID_FRAMEBUFFER_OPERATION: framebuffer:%d\n", status);+ }+}++static bool check_framebuffer_status() {+#ifdef _WIN32+ PROC proc = wglGetProcAddress("glCheckFramebufferStatusEXT");+ if (proc == nullptr) return true;+ GLenum s = reinterpret_cast<PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC>(proc)(+ GL_FRAMEBUFFER);+#else+ GLenum s = glCheckFramebufferStatus(GL_FRAMEBUFFER);+#endif+ if (s == GL_FRAMEBUFFER_UNDEFINED)+ printf("Warning: FB undefined: %d\n", s);+ else if (s == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)+ printf("Warning: FB incomplete(attachment): %d\n", s);+ else if (s == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT)+ printf("Warning: FB incomplete(missing attachment): %d\n", s);+ else if (s == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER)+ printf("Warning: FB incomplete(draw buffer): %d\n", s);+ else if (s == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER)+ printf("Warning: FB incomplete(read buffer): %d\n", s);+ else if (s == GL_FRAMEBUFFER_UNSUPPORTED)+ printf("Warning: FB unsupported: %d\n", s);+ else if (s == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE)+ printf("Warning: FB incomplete(multi-sample): %d\n", s);+ else if (s == GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS)+ printf("Warning: FB incomplete(multi-sample): %d\n", s);+ else if (s == GL_FRAMEBUFFER_COMPLETE)+ ;+ else+ printf("Warning: FB not complete(unknown cause): %d\n", s);+ return s == GL_FRAMEBUFFER_COMPLETE;+}++//-----------------------------------------------------------------------------++void SceneViewer::drawCameraStand() {+ GLint e = glGetError();+ check_framebuffer_status();+ assert(e == GL_NO_ERROR);++ TXshSimpleLevel::m_rasterizePli = rasterizePliToggle.getStatus();++ // display blank frame+ if (m_visualSettings.m_blankColor != TPixel::Transparent) {+ glClearColor(m_visualSettings.m_blankColor.r / 255.0f,+ m_visualSettings.m_blankColor.g / 255.0f,+ m_visualSettings.m_blankColor.b / 255.0f, 1.0);+ glClear(GL_COLOR_BUFFER_BIT);+ return;+ }++ // clear+ if (m_draw3DMode) {+ glEnable(GL_DEPTH_TEST);+ glDepthFunc(GL_ALWAYS);+ glClear(GL_DEPTH_BUFFER_BIT);+ glPushMatrix();+ mult3DMatrix();+ } else+ glDisable(GL_DEPTH_TEST);++ assert(glGetError() == GL_NO_ERROR);++ // draw table+ if (!m_draw3DMode && viewTableToggle.getStatus() && m_drawIsTableVisible &&+ m_visualSettings.m_colorMask == 0 && m_drawEditingLevel == false &&+ !m_drawCameraTest) {+ glPushMatrix();+ tglMultMatrix(m_drawTableAff);+ ViewerDraw::drawDisk(m_tableDLId);+ glPopMatrix();+ }++ // draw colorcard (with camera BG color)+ // Hide camera BG when level editing mode.+ if (m_drawEditingLevel == false && viewClcToggle.getStatus() &&+ !m_drawCameraTest) {+ glPushMatrix();+ tglMultMatrix(m_drawCameraAff);+ glEnable(GL_BLEND);+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);+ ViewerDraw::drawColorcard(m_visualSettings.m_colorMask);+ glDisable(GL_BLEND);+ glPopMatrix();+ }++ // Show white background when level editing mode.+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (m_drawEditingLevel && tool && tool->isEnabled()) {+ if (!m_isLocator) tool->setViewer(this);+ glPushMatrix();+ if (m_referenceMode == CAMERA3D_REFERENCE) {+ mult3DMatrix();+ tglMultMatrix(tool->getMatrix());+ } else {+ tglMultMatrix(getViewMatrix() * tool->getMatrix());+ }+ glScaled(m_dpiScale.x, m_dpiScale.y, 1);++ TImageP image = tool->getImage(false);++ TToonzImageP ti = image;+ TRasterImageP ri = image;+ TVectorImageP vi = image;+ if (ti) {+ TRect imgRect(0, 0, ti->getSize().lx - 1, ti->getSize().ly - 1);+ TRectD bbox = ToonzImageUtils::convertRasterToWorld(imgRect, ti);++ TPixel32 imgRectColor;+ // draw black rectangle instead, if the BlackBG check is ON+ if (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)+ imgRectColor = TPixel::Black;+ else+ imgRectColor = Preferences::instance()->getLevelEditorBoxColor();+ ToolUtils::fillRect(bbox * ti->getSubsampling(), imgRectColor);+ } else if (ri) {+ TRasterP ras = ri->getRaster();+ if (ras) {+ // Use excludsive bbox to draw bound rectangle+ TDimension size = ras->getSize();+ TRectD imgRect(0, 0, size.lx, size.ly);+ imgRect -= ras->getCenterD();++ TPixel32 imgRectColor;+ // draw black rectangle instead, if the BlackBG check is ON+ if (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)+ imgRectColor = TPixel::Black;+ else+ imgRectColor = Preferences::instance()->getLevelEditorBoxColor();+ ToolUtils::fillRect(imgRect * ri->getSubsampling(), imgRectColor);+ }+ } else if (vi) {+ TRectD bbox = vi->getBBox();++ TPixel32 imgRectColor;+ // draw black rectangle instead, if the BlackBG check is ON+ if (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)+ imgRectColor = TPixel::Black;+ else+ imgRectColor = Preferences::instance()->getLevelEditorBoxColor();+ ToolUtils::fillRect(bbox, imgRectColor);+ }+ glPopMatrix();+ }++ // draw 3dframe+ if (m_draw3DMode) {+ glDepthFunc(GL_LEQUAL);+ ViewerDraw::draw3DFrame(m_minZ, m_phi3D);+ glDepthFunc(GL_ALWAYS);+ }++ // draw scene+ assert(glGetError() == GL_NO_ERROR);+ drawScene();+ assert((glGetError()) == GL_NO_ERROR);+}++//-----------------------------------------------------------------------------++void SceneViewer::drawPreview() {+ const double inch = Stage::inch;+ TApp *app = TApp::instance();+ int row = app->getCurrentFrame()->getFrame();+ TCamera *currCamera = app->getCurrentScene()->getScene()->getCurrentCamera();+ TDimensionD cameraSize = currCamera->getSize();++ Previewer *previewer =+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW);++ TRasterP ras =+ previewer->getRaster(row, m_visualSettings.m_recomputeIfNeeded);+ if (ras) {+ TRectD previewStageRectD, cameraStageRectD = currCamera->getStageRect();++ TRect subCameraRect(currCamera->getInterestRect());+ if (m_previewMode == SUBCAMERA_PREVIEW && subCameraRect.getLx() > 0 &&+ subCameraRect.getLy() > 0)+ previewStageRectD = currCamera->getInterestStageRect();+ else+ previewStageRectD = cameraStageRectD;++ TAffine rasterToStageRef(+ previewStageRectD.getLx() / ras->getLx(), 0.0,+ previewStageRectD.x0 + 0.5 * previewStageRectD.getLx(), 0.0,+ previewStageRectD.getLy() / ras->getLy(),+ previewStageRectD.y0 + 0.5 * previewStageRectD.getLy());++ TDimension dim(width(), height());+ TAffine finalAff = m_drawCameraAff * rasterToStageRef;+ m_visualSettings.m_useTexture = !Preferences::instance()->useDrawPixel();+ ImagePainter::paintImage(TRasterImageP(ras), ras->getSize(), dim, finalAff,+ m_visualSettings, m_compareSettings, TRect());+ }++ glPushMatrix();+ tglMultMatrix(m_drawCameraAff);++ TRectD frameRect(cameraSize);+ frameRect.x1 *= inch;+ frameRect.y1 *= inch;+ frameRect -= 0.5 * (frameRect.getP00() + frameRect.getP11());++ if (m_visualSettings.m_blankColor != TPixel::Transparent) {+ tglColor(m_visualSettings.m_blankColor);+ tglFillRect(frameRect);+ }++ if (!previewer->isFrameReady(row) ||+ (app->getCurrentFrame()->isPlaying() && previewer->isBusy())) {+ glColor3d(1, 0, 0);++ tglDrawRect(frameRect);+ tglDrawRect(frameRect.enlarge(5));+ }++ glPopMatrix();+}++//-----------------------------------------------------------------------------++void SceneViewer::drawOverlay() {+ TApp *app = TApp::instance();++ // draw camera mask+ if (m_referenceMode == CAMERA_REFERENCE && !m_drawCameraTest) {+ glPushMatrix();+ tglMultMatrix(m_drawCameraAff);+ ViewerDraw::drawCameraMask(this);+ glPopMatrix();+ }++ // draw FieldGuide+ if (fieldGuideToggle.getStatus()) {+ glPushMatrix();+ tglMultMatrix(m_drawTableAff);+ ViewerDraw::drawFieldGuide();+ glPopMatrix();+ }++ if (!m_drawCameraTest) {+ // draw grid & guides+ if (viewGuideToggle.getStatus() &&+ ((m_vRuler && m_vRuler->getGuideCount()) ||+ (m_hRuler && m_hRuler->getGuideCount()))) {+ glPushMatrix();+ tglMultMatrix(getViewMatrix());+ ViewerDraw::drawGridAndGuides(+ this, (m_draw3DMode) ? m_zoomScale3D : m_viewAff[m_viewMode].det(),+ m_vRuler, m_hRuler, false);+ glPopMatrix();+ }++ // draw camera+ if (viewCameraToggle.getStatus() && m_drawEditingLevel == false) {+ unsigned long f = 0;+ if (m_referenceMode == CAMERA_REFERENCE)+ f |= ViewerDraw::CAMERA_REFERENCE;+ if (m_draw3DMode) f |= ViewerDraw::CAMERA_3D;+ if (m_previewMode == SUBCAMERA_PREVIEW || m_editPreviewSubCamera)+ f |= ViewerDraw::SUBCAMERA;+ if (m_draw3DMode)+ ViewerDraw::draw3DCamera(f, m_minZ, m_phi3D);+ else {+ glPushMatrix();+ tglMultMatrix(m_drawCameraAff);+ m_pixelSize = sqrt(tglGetPixelSize2()) * getDevPixRatio();+ ViewerDraw::drawCamera(f, m_pixelSize);+ glPopMatrix();+ }+ }++#ifdef WITH_CANON+ if (m_stopMotion->m_liveViewStatus == StopMotion::LiveViewOpen &&+ app->getCurrentFrame()->getFrame() ==+ m_stopMotion->getXSheetFrameNumber() - 1) {+ int x0, x1, y0, y1;+ rect().getCoords(&x0, &y0, &x1, &y1);+ x0 = (-(x1 / 2)) + 15;+ y0 = ((y1 / 2)) - 15;+ tglDrawDisk(TPointD(x0, y0), 10);+ }++ // draw Stop Motion Zoom Box+ if (m_stopMotion->m_liveViewStatus == 2 &&+ m_stopMotion->m_canon->m_pickLiveViewZoom) {+ glPushMatrix();+ tglMultMatrix(m_drawCameraAff);+ m_pixelSize = sqrt(tglGetPixelSize2()) * getDevPixRatio();+ TRect rect = m_stopMotion->m_canon->m_zoomRect;++ glColor3d(1.0, 0.0, 0.0);++ // border+ glBegin(GL_LINE_STRIP);+ glVertex2d(rect.x0, rect.y0);+ glVertex2d(rect.x0, rect.y1 - m_pixelSize);+ glVertex2d(rect.x1 - m_pixelSize, rect.y1 - m_pixelSize);+ glVertex2d(rect.x1 - m_pixelSize, rect.y0);+ glVertex2d(rect.x0, rect.y0);+ glEnd();++ glPopMatrix();+ }++#endif++ // safe area+ if (safeAreaToggle.getStatus() && m_drawEditingLevel == false &&+ !is3DView()) {+ glPushMatrix();+ tglMultMatrix(m_drawCameraAff);+ ViewerDraw::drawSafeArea();+ glPopMatrix();+ }++ // record fps (frame per second)+ if (app->getCurrentFrame()->isPlaying())+ m_FPS = getActualFrameRate();+ else+ m_FPS = 0;++ assert(glGetError() == GL_NO_ERROR);++ } //! cameraTest++ // draw 3d Top/Side Buttons+ if (m_draw3DMode && !m_isPicking) {+ tglColor(TPixel32::Black);++ GLdouble modelView3D[16];+ GLdouble projection3D[16];+ GLint viewport3D[4];++ glGetDoublev(GL_MODELVIEW_MATRIX, modelView3D);+ glGetDoublev(GL_PROJECTION_MATRIX, projection3D);+ glGetIntegerv(GL_VIEWPORT, viewport3D);++ if (m_phi3D > 0) {+ T3DPointD topRasterPos3D = computeNew3DPosition(+ T3DPointD(500, 500, 1000), TPointD(-10, -10), m_topRasterPos,+ modelView3D, projection3D, viewport3D, getDevPixRatio());+ glRasterPos3f(topRasterPos3D.x, topRasterPos3D.y, topRasterPos3D.z);+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);+ glDrawPixels(m_3DTop->getWrap(), m_3DTop->getLy(), TGL_FMT, TGL_TYPE,+ m_3DTop->getRawData());++ T3DPointD sideRasterPos3D = computeNew3DPosition(+ T3DPointD(-500, -500, 1000), TPointD(-10, -10), m_sideRasterPos,+ modelView3D, projection3D, viewport3D, getDevPixRatio());+ glRasterPos3f(sideRasterPos3D.x, sideRasterPos3D.y, sideRasterPos3D.z);+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);+ glDrawPixels(m_3DSideR->getWrap(), m_3DSideR->getLy(), TGL_FMT, TGL_TYPE,+ m_3DSideR->getRawData());+ } else {+ T3DPointD topRasterPos3D = computeNew3DPosition(+ T3DPointD(-500, 500, 1000), TPointD(-10, -10), m_topRasterPos,+ modelView3D, projection3D, viewport3D, getDevPixRatio());+ glRasterPos3f(topRasterPos3D.x, topRasterPos3D.y, topRasterPos3D.z);+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);+ glDrawPixels(m_3DTop->getWrap(), m_3DTop->getLy(), TGL_FMT, TGL_TYPE,+ m_3DTop->getRawData());++ T3DPointD sideRasterPos3D = computeNew3DPosition(+ T3DPointD(500, -500, 1000), TPointD(-10, -10), m_sideRasterPos,+ modelView3D, projection3D, viewport3D, getDevPixRatio());+ glRasterPos3f(sideRasterPos3D.x, sideRasterPos3D.y, sideRasterPos3D.z);+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);+ glDrawPixels(m_3DSideL->getWrap(), m_3DSideL->getLy(), TGL_FMT, TGL_TYPE,+ m_3DSideL->getRawData());+ }+ }++ if (m_draw3DMode) {+ glDisable(GL_DEPTH_TEST);+ glPopMatrix();+ assert(glGetError() == GL_NO_ERROR);+ }++ // draw tool gadgets+ TTool *tool = app->getCurrentTool()->getTool();+ TXshSimpleLevel *sl = app->getCurrentLevel()->getSimpleLevel();+ // Call tool->draw() even if the level is read only (i.e. to show hooks)+ if (tool && (tool->isEnabled() || (sl && sl->isReadOnly()))) {+ // tool->setViewer(this); // Moved at+ // drawBuildVars(), before drawing anything+ glPushMatrix();+ if (m_draw3DMode) {+ mult3DMatrix();+ tglMultMatrix(tool->getMatrix());+ } else+ tglMultMatrix(getViewMatrix() * tool->getMatrix());+ if (tool->getToolType() & TTool::LevelTool &&+ !app->getCurrentObject()->isSpline())+ glScaled(m_dpiScale.x, m_dpiScale.y, 1);+ m_pixelSize = sqrt(tglGetPixelSize2()) * getDevPixRatio();++ unsigned int hints = tool->getToolHints();++ // draw assistans and guidelines+ m_toolHasAssistants = false;+ if (hints & TTool::HintAssistantsAll) {+ bool markEnabled = hints & TTool::HintAssistantsEnabled;+ bool drawGuidelines = hints & TTool::HintAssistantsGuidelines;++ m_toolHasAssistants =+ TAssistant::scanAssistants(tool, // tool+ &m_toolPos, 1, // pointer positions+ nullptr, // out guidelines+ true, // draw+ false, // enabled only+ markEnabled, // mark enabled+ drawGuidelines, // draw guidelines+ nullptr); // skip image+ }++ // draw replicators+ m_toolReplicatedPoints.clear();+ if (hints & TTool::HintReplicatorsAll) {+ bool drawPoints = hints & TTool::HintReplicatorsPoints;+ bool markEnabled = hints & TTool::HintReplicatorsEnabled;+ TReplicator::PointList *points = nullptr;+ if (drawPoints) {+ m_toolReplicatedPoints.push_back(m_toolPos);+ points = &m_toolReplicatedPoints;+ }++ TReplicator::scanReplicators(tool, // tool+ points, // in/out points+ nullptr, // out modifiers+ true, // draw+ false, // enabled only+ markEnabled, // mark enabled+ drawPoints, // draw points+ nullptr); // skip image+ }++ // draw tool+ tool->draw();++ glPopMatrix();+ // Used (only in the T_RGBPicker tool) to notify and set the currentColor+ // outside the draw() methods:+ // using special style there was a conflict between the draw() methods of+ // the tool+ // and the generation of the icon inside the style editor (makeIcon()) which+ // use+ // another glContext+ if (tool->getName() == "T_RGBPicker") tool->onImageChanged();++ // draw cross at the center of the locator window+ if (m_isLocator) {+ glColor3d(1.0, 0.0, 0.0);+ tglDrawSegment(TPointD(-4, 0), TPointD(5, 0));+ tglDrawSegment(TPointD(0, -4), TPointD(0, 5));+ }+ }+}++//-----------------------------------------------------------------------------++void SceneViewer::drawViewerIndicators() {+ if (!Preferences::instance()->isViewerIndicatorEnabled()) return;++ QStringList checkTexts;++ // Frozen Viewer Indicator+ if (m_freezedStatus) checkTexts.append(tr("FROZEN"));++ // Motion Path Indicator+ TApp *app = TApp::instance();+ TStageObjectId objId = app->getCurrentObject()->getObjectId();+ TXsheet *xsh = app->getCurrentXsheet()->getXsheet();+ if (app->getCurrentObject()->isSpline())+ checkTexts.append(tr("Motion Path Selected"));++ // Check Indicators (disabled in Preview mode)+ ToonzCheck *tc = ToonzCheck::instance();+ int mask = tc->getChecks();+ if (!m_previewMode && mask) {+ if (mask & ToonzCheck::eTransparency)+ checkTexts.append(tr("Transparency Check"));+ if (mask & ToonzCheck::eInk) checkTexts.append(tr("Ink Check"));+ if (mask & ToonzCheck::eInk1) checkTexts.append(tr("Ink#1 Check"));+ if (mask & ToonzCheck::ePaint) checkTexts.append(tr("Paint Check"));+ if (mask & ToonzCheck::eInksOnly) checkTexts.append(tr("Inks Only Check"));+ if (mask & ToonzCheck::eBlackBg) checkTexts.append(tr("Black BG Check"));+ if (mask & ToonzCheck::eGap) checkTexts.append(tr("Fill Check"));+ if (mask & ToonzCheck::eAutoclose) checkTexts.append(tr("Gap Check"));+ }++ if (!checkTexts.size()) return;++ int devPixRatio = getDevPixRatio();++ int x0, x1, y0, y1;+ rect().getCoords(&x0, &y0, &x1, &y1);+ x0 = (-(x1 / (2 * devPixRatio))) + 15;+ y0 = ((y1 / (2 * devPixRatio))) - 25;++ glPushMatrix();+ glScaled(2 * devPixRatio, 2 * devPixRatio, 2 * devPixRatio);+ glColor3d(1.0, 0.0, 0.0);+ for (int i = 0; i < checkTexts.size(); i++) {+ int y = (y0 / 2) - (i * 10);+ tglDrawText(TPointD((x0 / 2), y), checkTexts[i].toStdString());+ }+ glPopMatrix();+}++//-----------------------------------------------------------------------------++static void drawFpsGraph(int t0, int t1) {+ glDisable(GL_BLEND);+ static std::deque<std::pair<int, int>> times;+ times.push_back(std::make_pair(t0, t1));+ while (times.size() > 200) times.pop_front();+ double x0 = 10, y0 = 10;+ double x1 = x0 + 200;+ double y1 = y0 + 150;+ glPushMatrix();+ glLoadIdentity();+ glColor3d(0, 0, 0);+ glRectd(x0, y0, x1, y1);+ glColor3d(0, 0.5, 1);+ glBegin(GL_LINE_STRIP);+ glVertex2d(x0, y0);+ glVertex2d(x1, y0);+ glVertex2d(x1, y1);+ glVertex2d(x0, y1);+ glVertex2d(x0, y0);+ glEnd();+ glColor3d(0.5, 0.5, 0.5);+ glBegin(GL_LINES);+ for (int y = y0 + 5; y < y1; y += 20) {+ glVertex2d(x0, y);+ glVertex2d(x1, y);+ }+ for (int i = 0; i < (int)times.size(); i++) {+ double x = x1 - i;+ glColor3d(1, 0, 0);+ glVertex2d(x, y0);+ glVertex2d(x, y0 + 5 + times[i].first / 5);+ glColor3d(0, 1, 0);+ glVertex2d(x, y0 + 5 + times[i].first / 5);+ glVertex2d(x, y0 + 5 + times[i].second / 5);+ }+ glEnd();+ glPopMatrix();+}++//-----------------------------------------------------------------------------++// #define FPS_HISTOGRAM++void SceneViewer::paintGL() {+#ifdef _DEBUG+ if (!check_framebuffer_status()) {+ /* QGLWidget の widget 生成/削除のタイミングで(platform によって?)+ * GL_FRAMEBUFFER_UNDEFINED の状態で paintGL() が呼ばれてしまうようだ */+ return;+ }+#endif+#ifdef MACOSX+ // following lines are necessary to solve a problem on iMac20+ // It seems that for some errors in the openGl implementation, buffers are not+ // set correctly.+ if (m_isMouseEntered && m_forceGlFlush) {+ m_isMouseEntered = false;+ m_forceGlFlush = false;+ glDrawBuffer(GL_FRONT);+ glFlush();+ glDrawBuffer(GL_BACK);+ }+#endif++#ifdef FPS_HISTOGRAM+ QTime time;+ time.start();+#endif++ if (!m_isPicking && m_lutCalibrator && m_lutCalibrator->isValid())+ m_fbo->bind();++ if (m_hRuler && m_vRuler) {+ if (!viewRulerToggle.getStatus() &&+ (m_hRuler->isVisible() || m_vRuler->isVisible())) {+ m_hRuler->hide();+ m_vRuler->hide();+ } else if (viewRulerToggle.getStatus() &&+ (!m_hRuler->isVisible() || !m_vRuler->isVisible())) {+ m_hRuler->show();+ m_vRuler->show();+ }+ }++ // Il freezed e' attivo ed e' in stato "normale": mostro l'immagine grabbata.+ if (m_freezedStatus == NORMAL_FREEZED) {+ assert(!!m_viewGrabImage);+ m_viewGrabImage->lock();+ glPushMatrix();+ glLoadIdentity();++ glRasterPos2d(0, 0);+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);++ glDrawPixels(m_viewGrabImage->getLx(), m_viewGrabImage->getLy(), TGL_FMT,+ TGL_TYPE, m_viewGrabImage->getRawData());++ glPopMatrix();+ m_viewGrabImage->unlock();++ if (!m_isPicking && m_lutCalibrator && m_lutCalibrator->isValid())+ m_lutCalibrator->onEndDraw(m_fbo);++ drawViewerIndicators();++ return;+ }++ drawBuildVars();++ // This seems not to be necessary for now.+ // copyFrontBufferToBackBuffer();++ drawEnableScissor();+ drawBackground();++ if (m_previewMode != FULL_PREVIEW) {+ drawCameraStand();+ }++ if (isPreviewEnabled()) drawPreview();++ drawOverlay();++ drawDisableScissor();++ drawViewerIndicators();++ // Il freezed e' attivo ed e' in stato "update": faccio il grab del viewer.+ if (m_freezedStatus == UPDATE_FREEZED) {+ m_viewGrabImage = rasterFromQImage(grabFramebuffer());+ m_freezedStatus = NORMAL_FREEZED;+ }++#ifdef FPS_HISTOGRAM+ int t0 = time.elapsed();+ glFlush();+ glFinish();+ int t1 = time.elapsed();+ drawFpsGraph(t0, t1);+#endif+ // TOfflineGL::setContextManager(0);++ if (!m_isPicking && m_lutCalibrator && m_lutCalibrator->isValid())+ m_lutCalibrator->onEndDraw(m_fbo);+}++//-----------------------------------------------------------------------------++void SceneViewer::drawScene() {+ TApp *app = TApp::instance();+ ToonzScene *scene = app->getCurrentScene()->getScene();+ int frame = app->getCurrentFrame()->getFrame();+ TXsheet *xsh = app->getCurrentXsheet()->getXsheet();+ TRect clipRect = getActualClipRect(getViewMatrix());+ clipRect += TPoint(width() * 0.5, height() * 0.5);++ ChildStack *childStack = scene->getChildStack();+ bool editInPlace = editInPlaceToggle.getStatus() &&+ !app->getCurrentFrame()->isEditingLevel();++ bool fillFullColorRaster = TXshSimpleLevel::m_fillFullColorRaster;+ TXshSimpleLevel::m_fillFullColorRaster = false;++ // Guided Drawing Check+ int useGuidedDrawing = Preferences::instance()->getGuidedDrawingType();+ TTool *tool = app->getCurrentTool()->getTool();+ int guidedFrontStroke = tool && tool->getViewer()+ ? tool->getViewer()->getGuidedFrontStroke()+ : -1;+ int guidedBackStroke =+ tool && tool->getViewer() ? tool->getViewer()->getGuidedBackStroke() : -1;++ m_minZ = 0;+ if (is3DView()) {+ Stage::OpenGlPainter painter(getViewMatrix(), clipRect, m_visualSettings,+ true, false);+ painter.enableCamera3D(true);+ painter.setPhi(m_phi3D);+ int xsheetLevel = 0;+ std::pair<TXsheet *, int> xr;+ if (editInPlace) {+ xr = childStack->getAncestor(frame);+ xsheetLevel = childStack->getAncestorCount();+ } else+ xr = std::make_pair(xsh, frame);++ Stage::VisitArgs args;+ args.m_scene = scene;+ args.m_xsh = xr.first;+ args.m_row = xr.second;+ args.m_col = app->getCurrentColumn()->getColumnIndex();+ OnionSkinMask osm = app->getCurrentOnionSkin()->getOnionSkinMask();+ args.m_osm = &osm;+ args.m_camera3d = true;+ args.m_xsheetLevel = xsheetLevel;+ args.m_currentFrameId =+ app->getCurrentXsheet()+ ->getXsheet()+ ->getCell(app->getCurrentFrame()->getFrame(), args.m_col)+ .getFrameId();+ args.m_isGuidedDrawingEnabled = useGuidedDrawing;+ args.m_guidedFrontStroke = guidedFrontStroke;+ args.m_guidedBackStroke = guidedBackStroke;++ // args.m_currentFrameId = app->getCurrentFrame()->getFid();+ Stage::visit(painter, args);++ m_minZ = painter.getMinZ();+ } else {+ // camera 2D (normale)+ TDimension viewerSize(width(), height());++ TAffine viewAff = getViewMatrix();++ if (editInPlace) {+ TAffine aff;+ if (scene->getChildStack()->getAncestorAffine(aff, frame))+ viewAff = viewAff * aff.inv();+ }++ m_visualSettings.m_showBBox = viewBBoxToggle.getStatus();++ Stage::RasterPainter painter(viewerSize, viewAff, clipRect,+ m_visualSettings, true);++ // darken blended view mode for viewing the non-cleanuped and stacked+ // drawings+ painter.setRasterDarkenBlendedView(+ Preferences::instance()+ ->isShowRasterImagesDarkenBlendedInViewerEnabled());++ TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();+ if (app->getCurrentFrame()->isEditingLevel()) {+ Stage::visit(painter, app->getCurrentLevel()->getLevel(),+ app->getCurrentFrame()->getFid(),+ app->getCurrentOnionSkin()->getOnionSkinMask(),+ frameHandle->isPlaying(), useGuidedDrawing, guidedBackStroke,+ guidedFrontStroke);+ } else {+ std::pair<TXsheet *, int> xr;+ int xsheetLevel = 0;+ if (editInPlace) {+ xr = scene->getChildStack()->getAncestor(frame);+ xsheetLevel = scene->getChildStack()->getAncestorCount();+ } else+ xr = std::make_pair(xsh, frame);++ Stage::VisitArgs args;+ args.m_scene = scene;+ args.m_xsh = xr.first;+ args.m_row = xr.second;+ args.m_col = app->getCurrentColumn()->getColumnIndex();+ OnionSkinMask osm = app->getCurrentOnionSkin()->getOnionSkinMask();+ args.m_osm = &osm;+ args.m_xsheetLevel = xsheetLevel;+ args.m_isPlaying = frameHandle->isPlaying();+ if (app->getCurrentLevel() && app->getCurrentLevel()->getLevel() &&+ !app->getCurrentLevel()->getLevel()->getSoundLevel())+ args.m_currentFrameId =+ app->getCurrentXsheet()+ ->getXsheet()+ ->getCell(app->getCurrentFrame()->getFrame(), args.m_col)+ .getFrameId();+ args.m_isGuidedDrawingEnabled = useGuidedDrawing;+ args.m_guidedFrontStroke = guidedFrontStroke;+ args.m_guidedBackStroke = guidedBackStroke;++#if defined(x64)+ if (m_stopMotion->m_alwaysUseLiveViewImages &&+ m_stopMotion->m_liveViewStatus > 0 &&+ frame != m_stopMotion->getXSheetFrameNumber() - 1 &&+ m_hasStopMotionImage && !m_stopMotion->m_reviewTimer->isActive()) {+ TRaster32P image;+ bool hasImage = m_stopMotion->loadLiveViewImage(frame, image);+ if (hasImage) {+ Stage::Player smPlayer;+ double dpiX, dpiY;+ m_stopMotionImage->getDpi(dpiX, dpiY);+ smPlayer.m_dpiAff = TScale(Stage::inch / dpiX, Stage::inch / dpiY);+ smPlayer.m_opacity = 255;+ smPlayer.m_sl = m_stopMotion->m_sl;+ args.m_liveViewImage = static_cast<TRasterImageP>(image);+ args.m_liveViewPlayer = smPlayer;+ // painter.onRasterImage(static_cast<TRasterImageP>(image).getPointer(),+ // smPlayer);+ }+ }+ if ( //! m_stopMotion->m_drawBeneathLevels &&+ m_stopMotion->m_liveViewStatus == 2 &&+ ( //! frameHandle->isPlaying() ||+ frame == m_stopMotion->getXSheetFrameNumber() - 1)) {+ if (m_hasStopMotionLineUpImage && m_stopMotion->m_showLineUpImage) {+ Stage::Player smPlayer;+ double dpiX, dpiY;+ m_stopMotionLineUpImage->getDpi(dpiX, dpiY);+ smPlayer.m_dpiAff = TScale(Stage::inch / dpiX, Stage::inch / dpiY);+ smPlayer.m_opacity = 255;+ smPlayer.m_sl = m_stopMotion->m_sl;+ args.m_lineupImage = m_stopMotionLineUpImage;+ args.m_lineupPlayer = smPlayer;+ // painter.onRasterImage(m_stopMotionLineUpImage.getPointer(),+ // smPlayer);+ }+ if (m_hasStopMotionImage) {+ Stage::Player smPlayer;+ double dpiX, dpiY;+ m_stopMotionImage->getDpi(dpiX, dpiY);+ smPlayer.m_dpiAff = TScale(Stage::inch / dpiX, Stage::inch / dpiY);+ bool hide_opacity = false;+#ifdef WITH_CANON+ hide_opacity = m_stopMotion->m_canon->m_zooming ||+ m_stopMotion->m_canon->m_pickLiveViewZoom ||+ !m_hasStopMotionLineUpImage;+#endif+ smPlayer.m_opacity =+ hide_opacity ? 255.0 : m_stopMotion->getOpacity();+ smPlayer.m_sl = m_stopMotion->m_sl;+ args.m_liveViewImage = m_stopMotionImage;+ args.m_liveViewPlayer = smPlayer;+ // painter.onRasterImage(m_stopMotionImage.getPointer(), smPlayer);+ }+ }+#endif // x64+ Stage::visit(painter, args);+ }++ assert(glGetError() == 0);+ if (ToonzCheck::instance()->getChecks() & ToonzCheck::eAutoclose) {+ TXshSimpleLevel *sl = app->getCurrentLevel()->getSimpleLevel();+ if (sl && sl->getType() & TXshLevelType::RASTER_TYPE) {+ TFrameId fid = app->getCurrentTool()->getTool()->getCurrentFid();+ painter.setCurrentImageId(sl->getImageId(fid, 0));+ }+ }+ painter.flushRasterImages();++ TXshSimpleLevel::m_fillFullColorRaster = fillFullColorRaster;++ assert(glGetError() == 0);+ if (m_viewMode != LEVEL_VIEWMODE)+ drawSpline(getViewMatrix(), clipRect,+ m_referenceMode == CAMERA3D_REFERENCE, m_pixelSize);+ assert(glGetError() == 0);++ // gather animated guide strokes' bounding boxes+ // it is used for updating viewer next time+ std::vector<TStroke *> guidedStrokes = painter.getGuidedStrokes();+ for (auto itr = guidedStrokes.begin(); itr != guidedStrokes.end(); ++itr) {+ m_guidedDrawingBBox += (*itr)->getBBox();+ }+ }+}++//------------------------------------------------------------------------------++void SceneViewer::mult3DMatrix() {+ glTranslated(m_pan3D.x, m_pan3D.y, 0);+ glScaled(m_zoomScale3D, m_zoomScale3D, 1);+ glRotated(m_theta3D, 1, 0, 0);+ glRotated(m_phi3D, 0, 1, 0);+}++//-----------------------------------------------------------------------------++double SceneViewer::projectToZ(const TPointD &delta) {+ glPushMatrix();+ mult3DMatrix();+ GLint viewport[4];+ double modelview[16], projection[16];+ glGetIntegerv(GL_VIEWPORT, viewport);+ for (int i = 0; i < 16; i++)+ projection[i] = (double)m_projectionMatrix.constData()[i];+ glGetDoublev(GL_MODELVIEW_MATRIX, modelview);++ double ax, ay, az, bx, by, bz;+ gluProject(0, 0, 0, modelview, projection, viewport, &ax, &ay, &az);+ gluProject(0, 0, 1, modelview, projection, viewport, &bx, &by, &bz);++ glPopMatrix();+ TPointD zdir(bx - ax, by - ay);+ double zdirLength2 = norm2(zdir);+ if (zdirLength2 > 0.0) {+ double dz = (delta * zdir) / zdirLength2;+ return dz;+ } else+ return 0.0;+}++//-----------------------------------------------------------------------------++TRect SceneViewer::getActualClipRect(const TAffine &aff) {+ TDimensionD viewerSize(width(), height());+ TRectD clipRect(viewerSize);++ if (is3DView()) {+ TPointD p00 = winToWorld(clipRect.getP00());+ TPointD p01 = winToWorld(clipRect.getP01());+ TPointD p10 = winToWorld(clipRect.getP10());+ TPointD p11 = winToWorld(clipRect.getP11());+ clipRect = TRectD(TPointD(std::min(p00.x, p01.x), std::min(p00.y, p10.y)),+ TPointD(std::max(p11.x, p10.x), std::max(p11.y, p01.y)));+ }+ // this condition will catch both cases of m_clipRect == empty and+ // m_clipRect == InvalidateAllRect+ else if (m_clipRect.isEmpty())+ clipRect -= TPointD(viewerSize.lx / 2, viewerSize.ly / 2);+ else {+ clipRect = aff * (m_clipRect.enlarge(3));+ }++ clipRect *=+ TRectD(viewerSize) - TPointD(viewerSize.lx / 2, viewerSize.ly / 2);+ return convert(clipRect);+}++//-----------------------------------------------------------------------------++TAffine4 SceneViewer::get3dViewMatrix() const {+ if (is3DView()) {+ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ double z = xsh->getStageObject(cameraId)->getZ(+ TApp::instance()->getCurrentFrame()->getFrame());++ TAffine4 affine;+ affine *= TAffine4::translation(m_pan3D.x, m_pan3D.y, z);+ affine *= TAffine4::scale(m_zoomScale3D, m_zoomScale3D, m_zoomScale3D);+ affine *= TAffine4::rotationX(M_PI_180 * m_theta3D);+ affine *= TAffine4::rotationY(M_PI_180 * m_phi3D);+ return affine;+ }++ int viewMode = TApp::instance()->getCurrentFrame()->isEditingLevel()+ ? LEVEL_VIEWMODE+ : SCENE_VIEWMODE;++ if (m_referenceMode == CAMERA_REFERENCE) {+ int frame = TApp::instance()->getCurrentFrame()->getFrame();+ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();+ TAffine aff = xsh->getCameraAff(frame);+ return TAffine4(m_viewAff[viewMode] * aff.inv());+ }++ return TAffine4(m_viewAff[viewMode]);+}++//-----------------------------------------------------------------------------++TAffine SceneViewer::getViewMatrix() const {+ int viewMode = TApp::instance()->getCurrentFrame()->isEditingLevel()+ ? LEVEL_VIEWMODE+ : SCENE_VIEWMODE;+ if (is3DView()) return TAffine();+ if (m_referenceMode == CAMERA_REFERENCE) {+ int frame = TApp::instance()->getCurrentFrame()->getFrame();+ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();+ TAffine aff = xsh->getCameraAff(frame);+ return m_viewAff[viewMode] * aff.inv();+ } else+ return m_viewAff[viewMode];+}++//-----------------------------------------------------------------------------++TAffine SceneViewer::getSceneMatrix() const {+ int viewMode = TApp::instance()->getCurrentFrame()->isEditingLevel()+ ? LEVEL_VIEWMODE+ : SCENE_VIEWMODE;+ if (is3DView()) return TAffine();+ return m_viewAff[viewMode];+}++//-----------------------------------------------------------------------------++void SceneViewer::setViewMatrix(const TAffine &aff, int viewMode) {+ m_viewAff[viewMode] = aff;+ // In case the previewer is on, request a delayed update+ if (m_previewMode != NO_PREVIEW) requestTimedRefresh();+}++//-----------------------------------------------------------------------------++bool SceneViewer::is3DView() const {+ bool isCameraTest = CameraTestCheck::instance()->isEnabled();+ return (m_referenceMode == CAMERA3D_REFERENCE && !isCameraTest);+}++//-----------------------------------------------------------------------------++void SceneViewer::invalidateAll() {+ m_clipRect = InvalidateAllRect;+ update();+ if (m_vRuler) m_vRuler->update();+ if (m_hRuler) m_hRuler->update();+}++//-----------------------------------------------------------------------------+/*! Pan the viewer by using "navigator" (red rectangle) in level strip+ */+void SceneViewer::navigatorPan(const QPoint &delta) {+ panQt(delta);+ m_pos += delta;+}++//-----------------------------------------------------------------------------++void SceneViewer::GLInvalidateAll() {+ m_clipRect = InvalidateAllRect;+ update();+ if (m_vRuler) m_vRuler->update();+ if (m_hRuler) m_hRuler->update();+}++//-----------------------------------------------------------------------------++void SceneViewer::GLInvalidateRect(const TRectD &rect) {+ // in case that GLInvalidateAll is called just before coming here,+ // ignore the clip rect and refresh entire viewer+ if (m_clipRect == InvalidateAllRect)+ return;+ else if (rect.isEmpty())+ m_clipRect = InvalidateAllRect;+ else {+ m_clipRect += rect;+ if (!m_guidedDrawingBBox.isEmpty()) {+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ TPointD topLeft = tool->getMatrix() * m_guidedDrawingBBox.getP00();+ TPointD bottomRight = tool->getMatrix() * m_guidedDrawingBBox.getP11();+ m_clipRect += TRectD(topLeft, bottomRight);+ }+ }+ update();+ if (m_vRuler) m_vRuler->update();+ if (m_hRuler) m_hRuler->update();+ m_guidedDrawingBBox.empty();+}+//-----------------------------------------------------------------------------++// delta.x: right panning, pixel; delta.y: down panning, pixel+void SceneViewer::panQt(const QPointF &delta) {+ if (delta == QPointF()) return;+ if (is3DView())+ m_pan3D += TPointD(delta.x(), -delta.y());+ else {+ // TAffine &viewAff = m_viewAff[m_viewMode];+ // viewAff = TTranslation(delta.x(), -delta.y()) * viewAff;+ setViewMatrix(TTranslation(delta.x(), -delta.y()) * m_viewAff[m_viewMode],+ m_viewMode);+ }+ invalidateAll();+ emit refreshNavi();+}++//-----------------------------------------------------------------------------++void SceneViewer::zoomQt(bool forward, bool reset) {+ TPointD delta(m_lastMousePos.x() - width() / 2,+ -m_lastMousePos.y() + height() / 2);++ if (is3DView()) {+ if (reset || ((m_zoomScale3D < 500 || !forward) &&+ (m_zoomScale3D > 0.01 || forward))) {+ double oldZoomScale = m_zoomScale3D;+ m_zoomScale3D =+ reset ? 1+ : ImageUtils::getQuantizedZoomFactor(m_zoomScale3D, forward);++ m_pan3D = -(m_zoomScale3D / oldZoomScale) * -m_pan3D;+ }+ } else {+ // a factor for getting pixel-based zoom ratio+ double dpiFactor = getDpiFactor();+ // when showing the viewer with full-screen mode,+ // add a zoom factor which can show image fitting with the screen size+ double zoomScaleFittingWithScreen = 0.0f;+ if (dpiFactor != 1.0) {+ // check if the viewer is in full screen mode+ ImageUtils::FullScreenWidget *fsWidget =+ dynamic_cast<ImageUtils::FullScreenWidget *>(parentWidget());+ if (fsWidget && (fsWidget->windowState() & Qt::WindowFullScreen) != 0)+ zoomScaleFittingWithScreen = getZoomScaleFittingWithScreen();+ }++ int i;++ for (i = 0; i < 2; i++) {+ TAffine &viewAff = m_viewAff[i];+ if (m_isFlippedX) viewAff = viewAff * TScale(-1, 1);+ if (m_isFlippedX) viewAff = viewAff * TScale(1, -1);+ double scale2 = std::abs(viewAff.det());+ if (m_isFlippedX) viewAff = viewAff * TScale(-1, 1);+ if (m_isFlippedX) viewAff = viewAff * TScale(1, -1);+ if (reset || ((scale2 < 100000 || !forward) &&+ (scale2 > 0.001 * 0.05 || forward))) {+ double oldZoomScale = sqrt(scale2) * dpiFactor;+ double zoomScale =+ reset ? 1+ : ImageUtils::getQuantizedZoomFactor(oldZoomScale, forward);++ // threshold value -0.001 is intended to absorb the error of calculation+ if ((oldZoomScale - zoomScaleFittingWithScreen) *+ (zoomScale - zoomScaleFittingWithScreen) <+ -0.001)+ zoomScale = zoomScaleFittingWithScreen;+ // zoom center = viewer center+ if (Preferences::instance()->getViewerZoomCenter())+ setViewMatrix(TScale(zoomScale / oldZoomScale) * viewAff, i);+ // zoom center = mouse pos+ else+ setViewMatrix(TTranslation(delta) * TScale(zoomScale / oldZoomScale) *+ TTranslation(-delta) * viewAff,+ i);+ }+ }+ }++ GLInvalidateAll();+ emit onZoomChanged();+}++//-----------------------------------------------------------------------------+/*! a factor for getting pixel-based zoom ratio+ */+double SceneViewer::getDpiFactor() {+ // When the current unit is "pixels", always use a standard dpi+ double cameraDpi = TApp::instance()+ ->getCurrentScene()+ ->getScene()+ ->getCurrentCamera()+ ->getDpi()+ .x;+ if (Preferences::instance()->getPixelsOnly()) {+ return Stage::inch / Stage::standardDpi;+ }++ // When preview mode, use a camera DPI+ else if (isPreviewEnabled()) {+ return Stage::inch / cameraDpi;+ }+ // When level editing mode, use an image DPI+ else if (TApp::instance()->getCurrentFrame()->isEditingLevel()) {+ TXshSimpleLevel *sl;+ sl = TApp::instance()->getCurrentLevel()->getSimpleLevel();+ if (!sl) return Stage::inch / cameraDpi;+ if (sl->getType() == PLI_XSHLEVEL) return Stage::inch / cameraDpi;+ if (sl->getImageDpi() != TPointD())+ return Stage::inch / sl->getImageDpi().x;+ if (sl->getDpi() != TPointD()) return Stage::inch / sl->getDpi().x;+ // no valid dpi, use camera dpi+ return Stage::inch / cameraDpi;+ }+ // When the special case in the scene editing mode:+ // If the option "ActualPixelViewOnSceneEditingMode" is ON,+ // use current level's DPI set in the level settings.+ else if (Preferences::instance()+ ->isActualPixelViewOnSceneEditingModeEnabled()) {+ if (CleanupPreviewCheck::instance()->isEnabled() ||+ CameraTestCheck::instance()->isEnabled()) {+ double cleanupCameraDpi = TApp::instance()+ ->getCurrentScene()+ ->getScene()+ ->getProperties()+ ->getCleanupParameters()+ ->m_camera.getDpi()+ .x;+ return Stage::inch / cleanupCameraDpi;+ } else {+ TXshSimpleLevel *sl;+ sl = TApp::instance()->getCurrentLevel()->getSimpleLevel();+ if (!sl) return Stage::inch / cameraDpi;+ if (sl->getType() == PLI_XSHLEVEL) return Stage::inch / cameraDpi;+ if (sl->getDpi() == TPointD()) return Stage::inch / cameraDpi;+ // use default value for the argument of getDpi() (=TFrameId::NO_FRAME)+ // so that the dpi of the first frame in the level will be returned.+ return Stage::inch / sl->getDpi().x;+ }+ }+ // When the scene editing mode without any option, use the camera dpi+ else {+ return Stage::inch / cameraDpi;+ }+}++//-----------------------------------------------------------------------------+/*! when showing the viewer with full-screen mode,+ add a zoom factor which can show image fitting with the screen size+*/++double SceneViewer::getZoomScaleFittingWithScreen() {+ TDimension imgSize;++ // get the image size to be rendered++ if (isPreviewEnabled())+ imgSize = TApp::instance()+ ->getCurrentScene()+ ->getScene()+ ->getCurrentCamera()+ ->getRes();+ else if (TApp::instance()->getCurrentFrame()->isEditingLevel()) {+ TXshSimpleLevel *sl = TApp::instance()->getCurrentLevel()->getSimpleLevel();+ if (!sl || sl->getType() == PLI_XSHLEVEL || sl->getImageDpi() == TPointD())+ return 0.0;++ imgSize = sl->getResolution();+ } else if (Preferences::instance()+ ->isActualPixelViewOnSceneEditingModeEnabled() &&+ !CleanupPreviewCheck::instance()->isEnabled() &&+ !CameraTestCheck::instance()->isEnabled()) {+ TXshSimpleLevel *sl = TApp::instance()->getCurrentLevel()->getSimpleLevel();+ if (!sl || sl->getType() == PLI_XSHLEVEL || sl->getDpi() == TPointD())+ return 0.0;+ imgSize = sl->getResolution();++ } else // SCENE_VIEWMODE+ return 0.0;++ // add small margin on the edge of the image+ int margin = 20;+ // get the desktop resolution+ QRect rec = QApplication::primaryScreen()->geometry();++ // fit to either direction+ int moni_x = rec.width() - (margin * 2);+ int moni_y = rec.height() - (margin * 2);+ return std::min((double)moni_x / (double)imgSize.lx,+ (double)moni_y / (double)imgSize.ly);+}++//-----------------------------------------------------------------------------++// center: window coordinate, pixels, topleft origin+void SceneViewer::zoomQt(const QPoint ¢er, double factor) {+ if (factor == 1.0) return;+ TPointD delta(center.x() - width() / 2, -center.y() + height() / 2);+ double oldZoomScale = m_zoomScale3D;++ if (is3DView()) {+ if ((m_zoomScale3D < 500 || factor < 1) &&+ (m_zoomScale3D > 0.01 || factor > 1)) {+ m_zoomScale3D *= factor;+ m_pan3D = -(m_zoomScale3D / oldZoomScale) * (delta - m_pan3D) + delta;+ }+ } else {+ int i;+ for (i = 0; i < 2; i++) {+ TAffine &viewAff = m_viewAff[i];+ double scale2 = fabs(viewAff.det());+ if ((scale2 < 100000 || factor < 1) &&+ (scale2 > 0.001 * 0.05 || factor > 1)) {+ if (i == m_viewMode) {+ // viewAff = TTranslation(delta) * TScale(factor) *+ // TTranslation(-delta) * viewAff;+ setViewMatrix(TTranslation(delta) * TScale(factor) *+ TTranslation(-delta) * viewAff,+ i);+ } else {+ // viewAff = TScale(factor) * viewAff;+ setViewMatrix(TScale(factor) * viewAff, i);+ }+ }+ }+ }++ GLInvalidateAll();+ emit onZoomChanged();+}++void SceneViewer::zoom(const TPointD ¢er, double factor) {+ zoomQt(QPoint(center.x, height() - center.y), factor);+}++//-----------------------------------------------------------------------------++void SceneViewer::flipX() {+ double flipAngle0 = (m_rotationAngle[0] * -1) * 2;+ double flipAngle1 = (m_rotationAngle[1] * -1) * 2;+ m_rotationAngle[0] += flipAngle0;+ m_rotationAngle[1] += flipAngle1;+ if (m_isFlippedX != m_isFlippedY) {+ flipAngle0 = -flipAngle0;+ flipAngle1 = -flipAngle1;+ }+ m_viewAff[0] = m_viewAff[0] * TRotation(flipAngle0) * TScale(-1, 1);+ m_viewAff[1] = m_viewAff[1] * TRotation(flipAngle1) * TScale(-1, 1);+ m_viewAff[0].a13 *= -1;+ m_viewAff[1].a13 *= -1;+ m_isFlippedX = !m_isFlippedX;+ invalidateAll();+ emit onZoomChanged();+ emit onFlipHChanged(m_isFlippedX);+}++//-----------------------------------------------------------------------------++void SceneViewer::flipY() {+ double flipAngle0 = (m_rotationAngle[0] * -1) * 2;+ double flipAngle1 = (m_rotationAngle[1] * -1) * 2;+ m_rotationAngle[0] += flipAngle0;+ m_rotationAngle[1] += flipAngle1;+ if (m_isFlippedX != m_isFlippedY) {+ flipAngle0 = -flipAngle0;+ flipAngle1 = -flipAngle1;+ }+ m_viewAff[0] = m_viewAff[0] * TRotation(flipAngle0) * TScale(1, -1);+ m_viewAff[1] = m_viewAff[1] * TRotation(flipAngle1) * TScale(1, -1);+ m_viewAff[0].a23 *= -1;+ m_viewAff[1].a23 *= -1;+ m_isFlippedY = !m_isFlippedY;+ invalidateAll();+ emit onZoomChanged();+ emit onFlipVChanged(m_isFlippedY);+}++void SceneViewer::rotateLeft() {+ double rotationAngle = (double)RotateAngle > 0 ? RotateAngle : 90.0;+ if (m_isFlippedX != m_isFlippedY) rotationAngle *= -1;++ TPointD center;++ if (RotateOnCameraCenter)+ center = TPointD(0, 0);+ else+ center = m_viewAff[m_viewMode].inv() * TPointD(0, 0);++ rotate(center, rotationAngle);+}++void SceneViewer::rotateRight() {+ double rotationAngle = (double)RotateAngle > 0 ? -RotateAngle : -90.0;+ if (m_isFlippedX != m_isFlippedY) rotationAngle *= -1;++ TPointD center;++ if (RotateOnCameraCenter)+ center = TPointD(0, 0);+ else+ center = m_viewAff[m_viewMode].inv() * TPointD(0, 0);++ rotate(center, rotationAngle);+}++//-----------------------------------------------------------------------------++void SceneViewer::zoomIn() {+ m_lastMousePos = rect().center();+ zoomQt(true, false);+}++//-----------------------------------------------------------------------------++void SceneViewer::zoomOut() {+ m_lastMousePos = rect().center();+ zoomQt(false, false);+}++//-----------------------------------------------------------------------------++void SceneViewer::rotate(const TPointD ¢er, double angle) {+ if (angle == 0) return;+ if (m_isFlippedX != m_isFlippedY) angle = -angle;+ m_rotationAngle[m_viewMode] += angle;+ TPointD realCenter = m_viewAff[m_viewMode] * center;+ setViewMatrix(TRotation(realCenter, angle) * m_viewAff[m_viewMode],+ m_viewMode);+ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::rotate3D(double dPhi, double dTheta) {+ if (dPhi == 0 && dTheta == 0) return;+ m_phi3D = (float)tcrop(m_phi3D + dPhi, -90.0, 90.0);+ m_theta3D = (float)tcrop(m_theta3D + dTheta, 0.0, 90.0);+ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::regeneratePreview() {+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW)->clear();+ update();+}++//-----------------------------------------------------------------------------++void SceneViewer::regeneratePreviewFrame() {+ Previewer::instance(m_previewMode == SUBCAMERA_PREVIEW)+ ->clear(TApp::instance()->getCurrentFrame()->getFrame());++ update();+}++//-----------------------------------------------------------------------------++void SceneViewer::swapCompared() {+ m_compareSettings.m_swapCompared = !m_compareSettings.m_swapCompared;+ update();+}++//-----------------------------------------------------------------------------++void SceneViewer::fitToCamera() {+ // Reset the view scale to 1:1.+ bool tempIsFlippedX = m_isFlippedX;+ bool tempIsFlippedY = m_isFlippedY;+ resetSceneViewer();++ m_isFlippedX = tempIsFlippedX;+ m_isFlippedY = tempIsFlippedY;++ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();+ int frame = TApp::instance()->getCurrentFrame()->getFrame();+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ TStageObject *camera = xsh->getStageObject(cameraId);+ TAffine cameraPlacement = camera->getPlacement(frame);+ double cameraZ = camera->getZ(frame);+ TAffine cameraAff =+ getViewMatrix() * cameraPlacement * TScale((1000 + cameraZ) / 1000);++ QRect viewRect = rect();+ TRectD cameraRect = ViewerDraw::getCameraRect();+ TPointD P00 = cameraAff * cameraRect.getP00();+ TPointD P10 = cameraAff * cameraRect.getP10();+ TPointD P01 = cameraAff * cameraRect.getP01();+ TPointD P11 = cameraAff * cameraRect.getP11();+ TPointD p0 = TPointD(std::min({P00.x, P01.x, P10.x, P11.x}),+ std::min({P00.y, P01.y, P10.y, P11.y}));+ TPointD p1 = TPointD(std::max({P00.x, P01.x, P10.x, P11.x}),+ std::max({P00.y, P01.y, P10.y, P11.y}));+ cameraRect = TRectD(p0.x, p0.y, p1.x, p1.y);++ // Pan+ if (!is3DView()) {+ TPointD cameraCenter = (cameraRect.getP00() + cameraRect.getP11()) * 0.5;+ panQt(QPoint(-cameraCenter.x, cameraCenter.y));+ }++ double xratio = (double)viewRect.width() / cameraRect.getLx();+ double yratio = (double)viewRect.height() / cameraRect.getLy();+ double ratio = std::min(xratio, yratio);+ if (ratio == 0.0) return;+ if (tempIsFlippedX)+ setViewMatrix(TScale(-1, 1) * m_viewAff[m_viewMode], m_viewMode);+ if (tempIsFlippedY)+ setViewMatrix(TScale(1, -1) * m_viewAff[m_viewMode], m_viewMode);+ // Scale and center on the center of \a rect.+ QPoint c = viewRect.center();+ zoom(TPointD(c.x(), c.y()), ratio);+ emit onFlipHChanged(m_isFlippedX);+ emit onFlipVChanged(m_isFlippedY);+}++//-----------------------------------------------------------------------------++void SceneViewer::fitToCameraOutline() {+ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();+ int frame = TApp::instance()->getCurrentFrame()->getFrame();+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ TStageObject *camera = xsh->getStageObject(cameraId);+ TAffine cameraPlacement = camera->getPlacement(frame);+ double cameraZ = camera->getZ(frame);+ TAffine cameraAff =+ getViewMatrix() * cameraPlacement * TScale((1000 + cameraZ) / 1000);++ QRect viewRect = rect();+ TRectD cameraRect = ViewerDraw::getCameraRect();+ TPointD P00 = cameraAff * cameraRect.getP00();+ TPointD P10 = cameraAff * cameraRect.getP10();+ TPointD P01 = cameraAff * cameraRect.getP01();+ TPointD P11 = cameraAff * cameraRect.getP11();+ TPointD p0 = TPointD(std::min({P00.x, P01.x, P10.x, P11.x}),+ std::min({P00.y, P01.y, P10.y, P11.y}));+ TPointD p1 = TPointD(std::max({P00.x, P01.x, P10.x, P11.x}),+ std::max({P00.y, P01.y, P10.y, P11.y}));+ cameraRect = TRectD(p0.x, p0.y, p1.x, p1.y);++ // Pan+ if (!is3DView()) {+ TPointD cameraCenter = (cameraRect.getP00() + cameraRect.getP11()) * 0.5;+ panQt(QPoint(-cameraCenter.x, cameraCenter.y));+ }++ double xratio = (double)viewRect.width() / cameraRect.getLx();+ double yratio = (double)viewRect.height() / cameraRect.getLy();+ double ratio = std::min(xratio, yratio);+ if (ratio == 0.0) return;++ // Scale and center on the center of \a rect.+ QPoint c = viewRect.center();+ zoom(TPointD(c.x(), c.y()), ratio);+ zoom(TPointD(c.x(), c.y()), 0.95);+}++//-----------------------------------------------------------------------------++void SceneViewer::resetSceneViewer() {+ m_visualSettings.m_sceneProperties =+ TApp::instance()->getCurrentScene()->getScene()->getProperties();++ for (int i = 0; i < m_viewAff.size(); ++i) {+ setViewMatrix(getNormalZoomScale(), i);+ m_rotationAngle[i] = 0.0;+ }++ m_pos = QPoint(0, 0);+ m_pan3D = TPointD(0, 0);+ m_zoomScale3D = 0.1;+ m_theta3D = 20;+ m_phi3D = 30;+ m_isFlippedX = false;+ m_isFlippedY = false;+ fitToCameraOutline();+ emit onZoomChanged();+ emit onFlipHChanged(m_isFlippedX);+ emit onFlipVChanged(m_isFlippedY);+ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::resetZoom() {+ TPointD realCenter(m_viewAff[m_viewMode].a13, m_viewAff[m_viewMode].a23);+ TAffine aff =+ getNormalZoomScale() * TRotation(realCenter, m_rotationAngle[m_viewMode]);+ aff.a13 = realCenter.x;+ aff.a23 = realCenter.y;+ if (m_isFlippedX) aff = aff * TScale(-1, 1);+ if (m_isFlippedY) aff = aff * TScale(1, -1);+ setViewMatrix(aff, m_viewMode);+ invalidateAll();+ emit onZoomChanged();+}++//-----------------------------------------------------------------------------++void SceneViewer::resetRotation() {+ double reverseRotatation = m_rotationAngle[m_viewMode] * -1;+ if (m_isFlippedX) reverseRotatation *= -1;+ if (m_isFlippedY) reverseRotatation *= -1;++ TPointD center;++ if (RotateOnCameraCenter)+ center = TPointD(0, 0);+ else+ center = m_viewAff[m_viewMode].inv() * TPointD(0, 0);++ rotate(center, reverseRotatation);+}++//-----------------------------------------------------------------------------++void SceneViewer::resetPosition() {+ m_viewAff[m_viewMode].a13 = 0.0;+ m_viewAff[m_viewMode].a23 = 0.0;+ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::setActualPixelSize() {+ TApp *app = TApp::instance();+ TXshLevel *l = app->getCurrentLevel()->getLevel();+ TXshSimpleLevel *sl = l ? l->getSimpleLevel() : 0;+ if (!sl) return;++ TFrameId fid(app->getCurrentFrame()->getFid());++ TPointD dpi;+ if (CleanupPreviewCheck::instance()->isEnabled()) {+ // The previewed cleanup image has no image infos yet - retrieve the dpi+ // through+ // the cleanup camera data+ CleanupParameters *cleanupParams = app->getCurrentScene()+ ->getScene()+ ->getProperties()+ ->getCleanupParameters();++ TDimension dim(0, 0);+ cleanupParams->getOutputImageInfo(dim, dpi.x, dpi.y);+ } else+ dpi = sl->getDpi(fid);++ const double inch = Stage::inch;+ TAffine tempAff = getNormalZoomScale();+ if (m_isFlippedX) tempAff = tempAff * TScale(-1, 1);+ if (m_isFlippedY) tempAff = tempAff * TScale(1, -1);+ TPointD tempScale = dpi;+ if (m_isFlippedX) tempScale.x = -tempScale.x;+ if (m_isFlippedY) tempScale.y = -tempScale.y;+ for (int i = 0; i < m_viewAff.size(); ++i)+ setViewMatrix(dpi == TPointD(0, 0)+ ? tempAff+ : TScale(tempScale.x / inch, tempScale.y / inch),+ i);++ m_pos = QPoint(0, 0);+ m_pan3D = TPointD(0, 0);+ m_zoomScale3D = 0.1;+ m_theta3D = 20;+ m_phi3D = 30;+ emit onZoomChanged();++ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::onLevelChanged() {+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool) {+ TXshLevel *level = TApp::instance()->getCurrentLevel()->getLevel();+ if (level && level->getSimpleLevel())+ m_dpiScale =+ getCurrentDpiScale(level->getSimpleLevel(), tool->getCurrentFid());+ else+ m_dpiScale = TPointD(1, 1);+ }+}+//-----------------------------------------------------------------------------+/*! when level is switched, update m_dpiScale in order to show white background+ * for Ink&Paint work properly+ */+void SceneViewer::onLevelSwitched() {+ invalidateToolStatus();+ TApp *app = TApp::instance();+ TTool *tool = app->getCurrentTool()->getTool();+ TXshLevel *level = app->getCurrentLevel()->getLevel();+ if (level && level->getSimpleLevel())+ m_dpiScale =+ getCurrentDpiScale(level->getSimpleLevel(), tool->getCurrentFid());+ else+ m_dpiScale = TPointD(1, 1);+}++//-----------------------------------------------------------------------------++void SceneViewer::onXsheetChanged() {+ m_forceGlFlush = true;+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool && tool->isEnabled()) tool->updateMatrix();+ onLevelChanged();+ GLInvalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::onObjectSwitched() {+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool && tool->isEnabled()) tool->updateMatrix();+ onLevelChanged();+ GLInvalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::onSceneChanged() {+ onLevelChanged();+ GLInvalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::onFrameSwitched() {+ invalidateToolStatus();++ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool && tool->isEnabled()) {+ tool->setViewer(this);+ tool->updateMatrix();+ tool->onEnter();+ }++ GLInvalidateAll();+}++//-----------------------------------------------------------------------------+/*! when tool options are changed, update tooltip immediately+ */+void SceneViewer::onToolChanged() {+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool) setToolCursor(this, tool->getCursorId());+ GLInvalidateAll();+}++//-----------------------------------------------------------------------------++int SceneViewer::pick(const TPointD &point) {+ // pick is typically called in a mouse event handler.+ // QGLWidget::makeCurrent() is not automatically called in these events.+ // (to exploit the bug: open the FxEditor preview and then select the edit+ // tool)+ m_isPicking = true;+ makeCurrent();+ assert(glGetError() == GL_NO_ERROR);+ GLint viewport[4];+ glGetIntegerv(GL_VIEWPORT, viewport);+ std::array<GLuint, 512> selectBuffer;+ glSelectBuffer(selectBuffer.size(), selectBuffer.data());+ glRenderMode(GL_SELECT);++ // definisco la matrice di proiezione+ glMatrixMode(GL_PROJECTION);+ GLdouble mat[16];+ glGetDoublev(GL_PROJECTION_MATRIX, mat);+ glPushMatrix();+ glLoadIdentity();+ gluPickMatrix(point.x, point.y, 5, 5, viewport);+ glMultMatrixd(mat);+ assert(glGetError() == GL_NO_ERROR);++ // disegno la scena+ glMatrixMode(GL_MODELVIEW);+ glPushMatrix();+ glInitNames();+ assert(glGetError() == GL_NO_ERROR);++ // WARNING: We have to draw the scene in CAMERASTAND mode. Observe that the+ // preview mode may+ // invoke event processing - therefore triggering other pick events while in+ // GL_SELECT+ // render mode...+ int previewMode = m_previewMode;+ m_previewMode = NO_PREVIEW;++ // OPTIMIZATION / QUICK FIX+ // A 1x1 clipping rect around the picked pos can very well be used instead of+ // redrawing+ // the *entire viewer*.+ // This is needed especially since some graphic cards (all NVidias we have+ // tested) are+ // very slow otherwise. This could be due to this particular rendering mode -+ // or because+ // we could be painting OUTSIDE a paintEvent()...++ TRectD oldClipRect(m_clipRect);+ m_clipRect = TRectD(point.x, point.y, point.x + 1, point.y + 1);++ paintGL(); // draw identifiable objects++ m_clipRect = oldClipRect;++ m_previewMode = previewMode;++ assert(glGetError() == GL_NO_ERROR);+ glPopMatrix();++ // rimetto a posto la matrice di proiezione+ glMatrixMode(GL_PROJECTION);+ glPopMatrix();+ glMatrixMode(GL_MODELVIEW);++ assert(glGetError() == GL_NO_ERROR);++ // conto gli hits+ int ret = -1;+ int hitCount = glRenderMode(GL_RENDER);+ GLuint *p = selectBuffer.data();+ for (int i = 0; i < hitCount; ++i) {+ GLuint nameCount = *p++;+ GLuint zmin = *p++;+ GLuint zmax = *p++;+ if (nameCount > 0) {+ GLuint name = *p;+ ret = name; // items.push_back(PickItem(name, zmin, zmax));+ }+ p += nameCount;+ }+ assert(glGetError() == GL_NO_ERROR);+ m_isPicking = false;+ return ret;+}++//-----------------------------------------------------------------------------++int SceneViewer::posToColumnIndex(const TPointD &p, double distance,+ bool includeInvisible) const {+ std::vector<int> ret;+ posToColumnIndexes(p, ret, distance, includeInvisible);+ return ret.empty() ? -1 : ret.back();+}++//-----------------------------------------------------------------------------++void SceneViewer::posToColumnIndexes(const TPointD &p,+ std::vector<int> &indexes, double distance,+ bool includeInvisible) const {+ int oldRasterizePli = TXshSimpleLevel::m_rasterizePli;+ TApp *app = TApp::instance();+ ToonzScene *scene = app->getCurrentScene()->getScene();+ TXsheet *xsh = app->getCurrentXsheet()->getXsheet();+ int frame = app->getCurrentFrame()->getFrame();+ int currentColumnIndex = app->getCurrentColumn()->getColumnIndex();+ OnionSkinMask osm = app->getCurrentOnionSkin()->getOnionSkinMask();++ TPointD pos = TPointD(p.x - width() / 2, p.y - height() / 2);+ Stage::Picker picker(getViewMatrix(), pos, m_visualSettings,+ getDevPixRatio());+ picker.setMinimumDistance(distance);++ TXshSimpleLevel::m_rasterizePli = 0;++ Stage::VisitArgs args;+ args.m_scene = scene;+ args.m_xsh = xsh;+ args.m_row = frame;+ args.m_col = currentColumnIndex;+ args.m_osm = &osm;+ args.m_onlyVisible = includeInvisible;++ Stage::visit(picker, args); /*+picker,+scene,+xsh,+frame,+currentColumnIndex,+osm,+false,+0,+false,+includeInvisible);+*/++ TXshSimpleLevel::m_rasterizePli = oldRasterizePli;+ picker.getColumnIndexes(indexes);+}++//-----------------------------------------------------------------------------++int SceneViewer::posToRow(const TPointD &p, double distance,+ bool includeInvisible, bool currentColumnOnly) const {+ int oldRasterizePli = TXshSimpleLevel::m_rasterizePli;+ TApp *app = TApp::instance();+ OnionSkinMask osm = app->getCurrentOnionSkin()->getOnionSkinMask();++ TPointD pos = TPointD(p.x - width() / 2, p.y - height() / 2);+ Stage::Picker picker(getViewMatrix(), pos, m_visualSettings,+ getDevPixRatio());+ picker.setMinimumDistance(distance);++ if (app->getCurrentFrame()->isEditingLevel()) {+ Stage::visit(picker, app->getCurrentLevel()->getLevel(),+ app->getCurrentFrame()->getFid(), osm,+ app->getCurrentFrame()->isPlaying(), false);+ } else {+ ToonzScene *scene = app->getCurrentScene()->getScene();+ TXsheet *xsh = app->getCurrentXsheet()->getXsheet();+ int frame = app->getCurrentFrame()->getFrame();+ int currentColumnIndex = app->getCurrentColumn()->getColumnIndex();++ TXshSimpleLevel::m_rasterizePli = 0;++ Stage::VisitArgs args;+ args.m_scene = scene;+ args.m_xsh = xsh;+ args.m_row = frame;+ args.m_col = currentColumnIndex;+ args.m_osm = &osm;+ args.m_onlyVisible = includeInvisible;++ if (currentColumnOnly) picker.setCurrentColumnIndex(currentColumnIndex);++ Stage::visit(picker, args);+ }+ TXshSimpleLevel::m_rasterizePli = oldRasterizePli;+ return picker.getRow();+}++//-----------------------------------------------------------------------------++void drawSpline(const TAffine &viewMatrix, const TRect &clipRect, bool camera3d,+ double pixelsize) {+ TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();++ TStageObjectId objId = TApp::instance()->getCurrentObject()->getObjectId();++ TStageObject *pegbar =+ objId != TStageObjectId::NoneId ? xsh->getStageObject(objId) : 0;+ const TStroke *stroke = 0;+ if (pegbar && pegbar->getSpline()) stroke = pegbar->getSpline()->getStroke();+ if (!stroke) return;++ int frame = TApp::instance()->getCurrentFrame()->getFrame();++ TAffine aff;+ double objZ = 0, objNoScaleZ = 0;+ if (objId != TStageObjectId::NoneId) {+ aff = xsh->getParentPlacement(objId, frame);+ objZ = xsh->getZ(objId, frame);+ objNoScaleZ = xsh->getStageObject(objId)->getGlobalNoScaleZ();+ }++ glPushMatrix();+ if (camera3d) {+ tglMultMatrix(aff);+ aff = TAffine();+ glTranslated(0, 0, objZ);+ } else {+ TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();+ double camZ = xsh->getZ(cameraId, frame);+ TAffine camAff = xsh->getPlacement(cameraId, frame);+ TAffine tmp;+ TStageObject::perspective(tmp, camAff, camZ, aff, objZ, objNoScaleZ);+ aff = viewMatrix * tmp;+ }++ if (TApp::instance()->getCurrentObject()->isSpline()) {+ glColor3d(1.0, 0.5, 0);+ glLineStipple(1, 0x18FF);+ } else {+ glLineStipple(1, 0xCCCC);+ glColor3d(1, 0, 1);+ }++ glEnable(GL_LINE_STIPPLE);+ tglMultMatrix(aff);++ double pixelSize = std::max(0.1, pixelsize);+ double strokeLength = stroke->getLength();+ int n = (int)(5 + (strokeLength / pixelSize) * 0.1);++ glBegin(GL_LINE_STRIP);+ for (int i = 0; i < n; i++)+ tglVertex(stroke->getPoint((double)i / (double)(n - 1)));+ glEnd();+ glDisable(GL_LINE_STIPPLE);+ int cpCount = stroke->getControlPointCount();+ for (int i = 0; i * 4 < cpCount; i++) {+ double t = stroke->getParameterAtControlPoint(i * 4);+ TPointD pos = stroke->getPoint(t);+ tglDrawText(pos, QString::number(i).toStdString().c_str());+ }++ if (pegbar) {+ TAffine parentAff = xsh->getParentPlacement(objId, frame);+ TAffine aff = xsh->getPlacement(objId, frame);+ TPointD center = Stage::inch * xsh->getCenter(objId, frame);+ glPushMatrix();+ tglMultMatrix(parentAff.inv() * TTranslation(aff * center));+ center = TPointD();++ // draw center+ // tglDrawDisk(center,pixelSize*5);+ tglDrawDisk(center, sqrt(tglGetPixelSize2()) * 5);++ glPopMatrix();+ }++ glPopMatrix();+}++//-----------------------------------------------------------------------------++void SceneViewer::resetInputMethod() {+ QGuiApplication::inputMethod()->reset();+}++//-----------------------------------------------------------------------------++void SceneViewer::set3DLeftSideView() {+ m_phi3D = -90;+ m_theta3D = 0;+ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::set3DRightSideView() {+ m_phi3D = 90;+ m_theta3D = 0;+ invalidateAll();+}++//-----------------------------------------------------------------------------++void SceneViewer::set3DTopView() {+ m_phi3D = 0;+ m_theta3D = 90;+ invalidateAll();+}++//-----------------------------------------------------------------------------++bool SceneViewer::canSwapCompared() const {+ return m_visualSettings.m_doCompare && m_previewMode != NO_PREVIEW;+}++//-----------------------------------------------------------------------------++TAffine SceneViewer::getNormalZoomScale() {+ return TScale(getDpiFactor()).inv();+}++//-----------------------------------------------------------------------------++void SceneViewer::invalidateToolStatus() {+ m_toolHasAssistants = false;+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ if (tool) {+ m_toolDisableReason = tool->updateEnabled();+ if (tool->isEnabled()) {+ setToolCursor(this, tool->getCursorId());+ tool->setViewer(this);+ tool->updateMatrix();+ } else+ setCursor(Qt::ForbiddenCursor);+ } else+ setCursor(Qt::ForbiddenCursor);+}++//-----------------------------------------------------------------------------+/*! return the viewer geometry in order to avoid picking the style outside of+ the viewer+ when using the stylepicker and the finger tools+*/++TRectD SceneViewer::getGeometry() const {+ int devPixRatio = getDevPixRatio();+ TTool *tool = TApp::instance()->getCurrentTool()->getTool();+ TPointD topLeft =+ tool->getMatrix().inv() * winToWorld(geometry().topLeft() * devPixRatio);+ TPointD bottomRight = tool->getMatrix().inv() *+ winToWorld(geometry().bottomRight() * devPixRatio);++ TObjectHandle *objHandle = TApp::instance()->getCurrentObject();+ if (tool->getToolType() & TTool::LevelTool && !objHandle->isSpline()) {+ topLeft.x /= m_dpiScale.x;+ topLeft.y /= m_dpiScale.y;+ bottomRight.x /= m_dpiScale.x;+ bottomRight.y /= m_dpiScale.y;+ }++ return TRectD(topLeft, bottomRight);+}++//-----------------------------------------------------------------------------++TRectD SceneViewer::getCameraRect() const {+ TRectD cameraRect = TApp::instance()+ ->getCurrentScene()+ ->getScene()+ ->getCurrentCamera()+ ->getStageRect();++ // return m_drawCameraAff * TRectD(cameraRect.x0, cameraRect.y0, cameraRect.x1+ // - m_pixelSize, cameraRect.y1 - m_pixelSize);+ return m_drawCameraAff * cameraRect;+}++//-----------------------------------------------------------------------------+/*! delete preview - subcamera executed from context menu+ */+void SceneViewer::doDeleteSubCamera() {+ PreviewSubCameraManager::instance()->deleteSubCamera(this);+}++//-----------------------------------------------------------------------------++void SceneViewer::bindFBO() {+ if (m_fbo) m_fbo->bind();+}++//-----------------------------------------------------------------------------++void SceneViewer::releaseFBO() {+ if (m_fbo) m_fbo->release();+}++//-----------------------------------------------------------------------------++void SceneViewer::onContextAboutToBeDestroyed() {+ if (!m_lutCalibrator) return;+ makeCurrent();+ m_lutCalibrator->cleanup();+ doneCurrent();+ disconnect(context(), SIGNAL(aboutToBeDestroyed()), this,+ SLOT(onContextAboutToBeDestroyed()));+}++//-----------------------------------------------------------------------------+// called from SceneViewer::initializeGL()++void SceneViewer::registerContext() {+ // release the old context, if any+ // this will be happen when dock / float the viewer panel.+ bool hasOldContext;+#ifdef _WIN32+ hasOldContext =+ (m_currentContext.first != nullptr && m_currentContext.second != nullptr);+#else+ hasOldContext = m_currentContext != nullptr;+#endif+ if (hasOldContext) {+ int ret = l_contexts.erase(m_currentContext);+ if (ret)+ TGLDisplayListsManager::instance()->releaseContext(m_currentContext);+ }++ // then, register context and the space Id correspondent to it.+ int displayListId;+ if (TApp::instance()->getMainWindow() &&+ TApp::instance()->getMainWindow()->isAncestorOf(this) &&+ QThread::currentThread() == qGuiApp->thread()) {+ // obtain displaySpaceId for main thread+ if (l_mainDisplayListsSpaceId == -1)+ l_mainDisplayListsSpaceId =+ TGLDisplayListsManager::instance()->storeProxy(new DummyProxy);++ displayListId = l_mainDisplayListsSpaceId;+ }+ // for the other cases (such as for floating viewer), it can't share the+ // context so+ // obtain different id+ else+ displayListId =+ TGLDisplayListsManager::instance()->storeProxy(new DummyProxy);+ TGlContext tglContext(tglGetCurrentContext());+ TGLDisplayListsManager::instance()->attachContext(displayListId, tglContext);+ l_contexts.insert(tglContext);+}