From c91d7e94d15ac2b7d98e3b53dbadf54be667978b Mon Sep 17 00:00:00 2001
From: Rene Brun <Rene.Brun@cern.ch>
Date: Wed, 8 Mar 2006 21:09:43 +0000
Subject: [PATCH] From Timur Pocheptsov:
-TGLPixmap - removed and replaced by TGLViewer (most of the TGLViewer
functionality is available in pad now);
-TGLHistPainter - zooming/panning added for legoes/surfaces;
-TGLViewerEditor - TGLViewer's editor for pad (lights/clipping/guides
manipulation).
-TRootCanvas :
minor changes to support mouse wheel event in gl viewer in a pad
-TCanvas :
a)changes to process keyboard events correctly
b)changes to process mouse will events
-TVirtualViewer3D :
changes in interface for TGLManager (win32 implementation of TGLManager
requires some functions and cannot be dependant from TGLViewer)
-Added class TVirtualGLManipulator - base for TGLManip - again, required
mostly by TGWin32GL.
git-svn-id: http://root.cern.ch/svn/root/trunk@14203 27541ba8-7e3a-0410-8455-c3a389f83636
---
base/inc/LinkDef1.h | 3 +-
base/inc/TVirtualGL.h | 23 +-
base/inc/TVirtualViewer3D.h | 6 +-
base/src/TVirtualGL.cxx | 5 +-
gl/Module.mk | 5 +-
gl/inc/LinkDef.h | 2 +-
gl/inc/TGLHistPainter.h | 16 +-
gl/inc/TGLManip.h | 8 +-
gl/inc/TGLPixmap.h | 104 --
gl/inc/TGLViewer.h | 9 +-
gl/inc/TGLViewerEditor.h | 97 ++
gl/inc/TX11GL.h | 7 +-
gl/src/TGLHistPainter.cxx | 87 +-
gl/src/TGLManip.cxx | 5 +-
gl/src/TGLPixmap.cxx | 1356 ------------------------
gl/src/TGLViewer.cxx | 190 +++-
gl/src/TGLViewerEditor.cxx | 448 ++++++++
gl/src/TX11GL.cxx | 32 +-
gpad/src/TCanvas.cxx | 44 +-
gui/src/TRootCanvas.cxx | 21 +-
tutorials/rootgeom.C | 3 +-
win32gdk/inc/TGWin32GL.h | 8 +-
win32gdk/inc/TGWin32VirtualGLProxy.h | 5 +-
win32gdk/src/TGWin32GL.cxx | 26 +-
win32gdk/src/TGWin32VirtualGLProxy.cxx | 5 +-
25 files changed, 964 insertions(+), 1551 deletions(-)
delete mode 100644 gl/inc/TGLPixmap.h
create mode 100644 gl/inc/TGLViewerEditor.h
delete mode 100644 gl/src/TGLPixmap.cxx
create mode 100644 gl/src/TGLViewerEditor.cxx
diff --git a/base/inc/LinkDef1.h b/base/inc/LinkDef1.h
index 4ac18f243a7..5cb914f38ff 100644
--- a/base/inc/LinkDef1.h
+++ b/base/inc/LinkDef1.h
@@ -1,4 +1,4 @@
-/* @(#)root/base:$Name: $:$Id: LinkDef1.h,v 1.32 2005/11/17 14:43:17 couet Exp $ */
+/* @(#)root/base:$Name: $:$Id: LinkDef1.h,v 1.33 2006/01/23 21:50:26 brun Exp $ */
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
@@ -155,6 +155,7 @@
#pragma link C++ class TVirtualGLImp;
#pragma link C++ class TGLManager;
#pragma link C++ class TVirtualGLPainter;
+#pragma link C++ class TVirtualGLManip;
#pragma link C++ class TVirtualPS;
#pragma link C++ class TVirtualUtil3D;
#pragma link C++ class TVirtualUtilHist;
diff --git a/base/inc/TVirtualGL.h b/base/inc/TVirtualGL.h
index a60bb6a40cc..b7f87f9aed2 100644
--- a/base/inc/TVirtualGL.h
+++ b/base/inc/TVirtualGL.h
@@ -1,4 +1,4 @@
-// @(#)root/base:$Name: $:$Id: TVirtualGL.h,v 1.27 2006/02/03 21:55:38 pcanal Exp $
+// @(#)root/base:$Name: $:$Id: TVirtualGL.h,v 1.28 2006/02/06 16:15:12 couet Exp $
// Author: Valery Fine(fine@vxcern.cern.ch) 05/03/97
/*************************************************************************
@@ -174,10 +174,6 @@ public:
R__EXTERN TVirtualGL *(*gPtr2VirtualGL)();
#endif
-//This class (and its descendants) in future will replace (?)
-//TVirtualGL/TGLKernel/TGWin32GL/TGX11GL
-
-
class TVirtualGLPainter {
public:
virtual ~TVirtualGLPainter(){}
@@ -186,6 +182,18 @@ public:
ClassDef(TVirtualGLPainter, 0); // Interface for OpenGL painter
};
+//We need this class to implement TGWin32GLManager's SelectManip
+class TVirtualGLManip {
+public:
+ virtual ~TVirtualGLManip(){}
+ virtual Bool_t Select(const TGLCamera & camera, const TGLRect & rect, const TGLBoundingBox & sceneBox) = 0;
+
+ ClassDef(TVirtualGLManip, 0); //Interface for GL manipulator
+};
+
+//This class (and its descendants) in future will replace (?)
+//TVirtualGL/TGLKernel/TGWin32GL/TGX11GL
+
class TGLManager : public TNamed {
public:
TGLManager();
@@ -221,7 +229,10 @@ public:
//functions to switch between threads in win32
virtual void DrawViewer(TVirtualViewer3D *vv) = 0;
- virtual TObject* Select(TVirtualViewer3D *vv, Int_t x, Int_t y) = 0;
+ //
+ virtual Bool_t SelectViewer(TVirtualViewer3D *viewer, const TGLRect *selRect) = 0;
+ virtual Bool_t SelectManip(TVirtualGLManip *manip, const TGLCamera *camera, const TGLRect *rect, const TGLBoundingBox *sceneBox) = 0;
+ //
virtual void PaintSingleObject(TVirtualGLPainter *) = 0;
//EPS/PDF output
virtual void PrintViewer(TVirtualViewer3D *vv) = 0;
diff --git a/base/inc/TVirtualViewer3D.h b/base/inc/TVirtualViewer3D.h
index 331f183b30c..c4b3e518f8c 100644
--- a/base/inc/TVirtualViewer3D.h
+++ b/base/inc/TVirtualViewer3D.h
@@ -1,4 +1,4 @@
-// @(#)root/base:$Name: $:$Id: TVirtualViewer3D.h $
+// @(#)root/base:$Name: $:$Id: TVirtualViewer3D.h,v 1.9 2006/01/30 17:42:05 rdm Exp $
// Author: Olivier Couet 05/10/2004
/*************************************************************************
@@ -38,6 +38,7 @@
class TBuffer3D;
class TVirtualPad;
+class TGLRect;
class TVirtualViewer3D : public TObject
{
@@ -69,6 +70,9 @@ public:
virtual TObject *SelectObject(Int_t, Int_t){return 0;}
virtual void DrawViewer(){}
+ virtual void DoDraw(){}
+ virtual Bool_t DoSelect(const TGLRect &){return kFALSE;}
+
virtual void PrintObjects(){}
static TVirtualViewer3D *Viewer3D(TVirtualPad *pad = 0, Option_t *type = "");
diff --git a/base/src/TVirtualGL.cxx b/base/src/TVirtualGL.cxx
index 8fd587d34dc..f4e205bc494 100644
--- a/base/src/TVirtualGL.cxx
+++ b/base/src/TVirtualGL.cxx
@@ -1,4 +1,4 @@
-// @(#)root/base:$Name: $:$Id: TVirtualGL.cxx,v 1.5 2005/11/16 20:04:12 pcanal Exp $
+// @(#)root/base:$Name: $:$Id: TVirtualGL.cxx,v 1.6 2005/11/17 14:43:17 couet Exp $
// Author: Valery Fine(fine@vxcern.cern.ch) 05/03/97
//////////////////////////////////////////////////////////////////////////
@@ -78,3 +78,6 @@ TGLManager *&TGLManager::Instance()
}
ClassImp(TVirtualGLPainter)
+
+
+ClassImp(TVirtualGLManip)
diff --git a/gl/Module.mk b/gl/Module.mk
index cf8b7839eec..9278c3ac68f 100644
--- a/gl/Module.mk
+++ b/gl/Module.mk
@@ -39,9 +39,12 @@ GLLIBS := $(OPENGLLIBDIR) $(OPENGLULIB) $(OPENGLLIB) \
$(X11LIBDIR) -lX11 -lXext -lXmu -lXi -lm
endif
ifeq ($(ARCH),win32)
-GLLIBS := opengl32.lib glu32.lib $(LPATH)/libGraf.lib $(LPATH)/libHist.lib
+GLLIBS := opengl32.lib glu32.lib $(LPATH)/libGraf.lib $(LPATH)/libHist.lib $(LPATH)/libGed.lib
+else
+GLLIBS += $(LPATH)/libGed.$(SOEXT)
endif
+
GLO := $(GLS:.cxx=.o)
GLO1 := $(GLS1:.c=.o)
diff --git a/gl/inc/LinkDef.h b/gl/inc/LinkDef.h
index 88664653b2c..38e506a1aca 100644
--- a/gl/inc/LinkDef.h
+++ b/gl/inc/LinkDef.h
@@ -65,8 +65,8 @@
#pragma link C++ class TGLPolyMarker;
#pragma link C++ class TGLCylinder;
#pragma link C++ class TGLSphere;
-#pragma link C++ class TGLPixmap;
#pragma link C++ class TGLHistPainter;
+#pragma link C++ class TGLViewerEditor;
#ifndef _WIN32
#pragma link C++ class TX11GL;
#pragma link C++ class TX11GLManager;
diff --git a/gl/inc/TGLHistPainter.h b/gl/inc/TGLHistPainter.h
index ab739f02559..3124af977d8 100644
--- a/gl/inc/TGLHistPainter.h
+++ b/gl/inc/TGLHistPainter.h
@@ -20,6 +20,14 @@
#include "TGLUtil.h"
#endif
+#ifndef ROOT_TPoint
+#include "TPoint.h"
+#endif
+
+#ifndef ROOT_TGLOrthoCamera
+#include "TGLOrthoCamera.h"
+#endif
+
class TString;
class TAxis;
class TF3;
@@ -148,7 +156,11 @@ private:
std::vector<UChar_t> fTexture;
void (TGLHistPainter::*fCurrentPainter)()const;
mutable Int_t fFrontPoint;
-
+
+ Double_t fZoom;
+ TGLVertex3 fPan;
+ TPoint fCurrPos;
+
public:
TGLHistPainter(TH1 *hist);
~TGLHistPainter();
@@ -221,6 +233,8 @@ private:
void SetTransformation()const;
void ClearBuffers()const;
+
+ void Pan(Int_t newX, Int_t newY);
Bool_t Select(Int_t x, Int_t y)const;
void SelectAxes(Int_t front, Int_t x, Int_t y)const;
diff --git a/gl/inc/TGLManip.h b/gl/inc/TGLManip.h
index 3f663a1def8..4eaf98cfa1f 100644
--- a/gl/inc/TGLManip.h
+++ b/gl/inc/TGLManip.h
@@ -1,4 +1,4 @@
-// @(#)root/gl:$Name: $:$Id: TGLManip.h,v 1.8 2006/02/21 16:39:49 brun Exp $
+// @(#)root/gl:$Name: $:$Id: TGLManip.h,v 1.9 2006/02/23 16:44:51 brun Exp $
// Author: Richard Maunder 16/09/2005
/*************************************************************************
@@ -12,6 +12,9 @@
#ifndef ROOT_TGLManip
#define ROOT_TGLManip
+#ifndef ROOT_TVirtualGL
+#include "TVirtualGL.h"
+#endif
#ifndef ROOT_TPoint
#include "TPoint.h"
#endif
@@ -44,8 +47,7 @@ class TGLViewer;
// some common mouse action handling/tracking. //
//////////////////////////////////////////////////////////////////////////
-class TGLManip // TODO Should derive from TGLDrawable or TGLPhysicalShape
-{
+class TGLManip : public TVirtualGLManip {
protected:
TGLPhysicalShape * fShape; //! manipulated shape
UInt_t fSelectedWidget; //! active width (axis) component
diff --git a/gl/inc/TGLPixmap.h b/gl/inc/TGLPixmap.h
deleted file mode 100644
index 40765f71473..00000000000
--- a/gl/inc/TGLPixmap.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// @(#)root/gl:$Name: $:$Id: TGLPixmap.h,v 1.5 2006/02/06 16:15:13 couet Exp $
-// Author: Timur Pocheptsov 18/08/2005
-
-/*************************************************************************
- * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
- * All rights reserved. *
- * *
- * For the licensing terms see $ROOTSYS/LICENSE. *
- * For the list of contributors see $ROOTSYS/README/CREDITS. *
- *************************************************************************/
-
-#ifndef ROOT_TGLPixmap
-#define ROOT_TGLPixmap
-
-#include <utility>
-
-#ifndef ROOT_TVirtualViewer3D
-#include "TVirtualViewer3D.h"
-#endif
-#ifndef ROOT_TArcBall
-#include "TArcBall.h"
-#endif
-#ifndef ROOT_TPoint
-#include "TPoint.h"
-#endif
-
-class GLSelection;
-class GLSceneObject;
-class GLCamera;
-class TBuffer3D;
-class TVirtualPad;
-class TGLRender;
-
-class TGLPixmap : public TVirtualViewer3D {
-private:
- GLCamera *fCamera;
- Double_t fViewVolume[4];
- Double_t fZoom[4];
- Int_t fActiveViewport[4];
- Int_t fLightMask;
- TGLRender *fRender;
-
- typedef std::pair<Double_t, Double_t> PDD_t;
- PDD_t fRangeX, fRangeY, fRangeZ, fLastPosRot;
- Double_t fXc, fYc, fZc;
- Double_t fRad;
-
- Bool_t fPressed;
- TArcBall fArcBall;
-
- UInt_t fNbShapes;
- TPoint fLastPos;
-
- Int_t fGLDevice;
-
- GLSceneObject *fSelectedObj;
- enum EAction{kNoAction, kRotating, kPicking, kZooming};
- EAction fAction;
- Bool_t fBuildingScene;
- TVirtualPad *fPad;
- Bool_t fFirstScene;
-
-public:
- TGLPixmap(TVirtualPad * pad);
- ~TGLPixmap();
-
- // TVirtualViewer3D interface
- virtual Bool_t PreferLocalFrame() const;
- virtual void BeginScene();
- virtual Bool_t BuildingScene() const { return fBuildingScene; }
- virtual void EndScene();
- Int_t AddObject(const TBuffer3D &buffer, Bool_t *addChild);
- Int_t AddObject(UInt_t, const TBuffer3D &, Bool_t *) {return 0;}
- virtual Bool_t OpenComposite(const TBuffer3D & buffer, Bool_t * addChildren = 0);
- virtual void CloseComposite();
- virtual void AddCompositeOp(UInt_t operation);
- TObject *SelectObject(Int_t x, Int_t y);
- Int_t DistancetoPrimitive(Int_t px, Int_t py);
-
-/////////////////////////////////////////
- void ZoomIn();// *MENU*
- void ZoomOut();// *MENU*
- void PrintObjects();// *MENU*
-
- void ExecuteEvent(Int_t type, Int_t px, Int_t py);
- void DrawViewer();
-private:
- void CreateViewer();
- void DrawObjects()const;
- void UpdateRange(const GLSelection *box);
- void CalculateViewports();
- void CalculateViewvolumes();
- void CreateCameras();
-
- Bool_t MakeCurrent()const;
-
- //non-copyable class
- TGLPixmap(const TGLPixmap &);
- TGLPixmap & operator = (const TGLPixmap &);
-
- ClassDef(TGLPixmap, 0); //Temporary gl pad viewer
-};
-
-#endif
diff --git a/gl/inc/TGLViewer.h b/gl/inc/TGLViewer.h
index 5e19c8505c1..05d30936f92 100644
--- a/gl/inc/TGLViewer.h
+++ b/gl/inc/TGLViewer.h
@@ -1,4 +1,4 @@
-// @(#)root/gl:$Name: $:$Id: TGLViewer.h,v 1.22 2006/01/26 11:59:41 brun Exp $
+// @(#)root/gl:$Name: $:$Id: TGLViewer.h,v 1.24 2006/02/08 10:49:26 couet Exp $
// Author: Richard Maunder 25/05/2005
/*************************************************************************
@@ -190,7 +190,9 @@ private:
protected:
TGLWindow * fGLWindow; //! remove - replace with TGLManager
-
+ //NEW
+ Int_t fGLDevice; //!for embedded gl viewer
+ //NEW
// Overloadable
virtual void PostSceneBuildSetup();
virtual void SelectionChanged(); // *SIGNAL*
@@ -198,6 +200,7 @@ protected:
public:
TGLViewer(TVirtualPad * pad, Int_t x, Int_t y, UInt_t width, UInt_t height);
+ TGLViewer(TVirtualPad * pad);
virtual ~TGLViewer();
// TVirtualViewer3D interface
@@ -212,6 +215,8 @@ public:
virtual Bool_t OpenComposite(const TBuffer3D & buffer, Bool_t * addChildren = 0);
virtual void CloseComposite();
virtual void AddCompositeOp(UInt_t operation);
+
+ Int_t GetDev()const{return fGLDevice;}
// External GUI component interface
void SetDrawStyle(TGLDrawFlags::EStyle style);
diff --git a/gl/inc/TGLViewerEditor.h b/gl/inc/TGLViewerEditor.h
new file mode 100644
index 00000000000..18ec313ea16
--- /dev/null
+++ b/gl/inc/TGLViewerEditor.h
@@ -0,0 +1,97 @@
+#ifndef ROOT_TGLViewerEditor
+#define ROOT_TGLViewerEditor
+
+#include <memory>
+
+#ifndef ROOT_TGedFrame
+#include "TGedFrame.h"
+#endif
+
+#ifndef ROOT_TGLUtil
+#include "TGLUtil.h"
+#endif
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGButtonGroup;
+class TGroupFrame;
+class TGRadioButton;
+class TGTabElement;
+class TGButton;
+class TGLViewer;
+class TGTab;
+
+class TGLViewerEditor : public TGedFrame {
+private:
+ //Pointers to manipulate with tabs
+ TGTabElement *fGuidesTabEl;
+ TGTabElement *fClipTabEl;
+ TGCompositeFrame *fGuidesFrame;
+ TGCompositeFrame *fClipFrame;
+ //"Lights" tab's controls
+ TGGroupFrame *fLightFrame;
+ TGButton *fTopLight;
+ TGButton *fRightLight;
+ TGButton *fBottomLight;
+ TGButton *fLeftLight;
+ TGButton *fFrontLight;
+ //"Guides" tab's controls
+ TGButtonGroup *fAxesContainer;
+ TGRadioButton *fAxesNone;
+ TGRadioButton *fAxesEdge;
+ TGRadioButton *fAxesOrigin;
+ TGGroupFrame *fRefContainer;
+
+ TGCheckButton *fReferenceOn;
+ TGNumberEntry *fReferencePosX;
+ TGNumberEntry *fReferencePosY;
+ TGNumberEntry *fReferencePosZ;
+
+ //"Cplipping" tab's controls
+ EClipType fCurrentClip;
+ TGButtonGroup *fTypeButtons;
+
+ TGCompositeFrame *fPlanePropFrame;
+ TGNumberEntry *fPlaneProp[4];
+
+ TGCompositeFrame *fBoxPropFrame;
+ TGNumberEntry *fBoxProp[6];
+ TGCheckButton *fEdit;
+ TGButton *fApplyButton;
+ //Model
+ TGLViewer *fViewer;
+
+ void ConnectSignals2Slots();
+
+ TGLViewerEditor(const TGLViewerEditor &);
+ TGLViewerEditor &operator = (const TGLViewerEditor &);
+
+ void CreateLightsTab();
+ void CreateGuidesTab();
+ void CreateClippingTab();
+
+public:
+ TGLViewerEditor(const TGWindow *p, Int_t id,
+ Int_t width = 140, Int_t height = 30,
+ UInt_t options = kChildFrame,
+ Pixel_t back = GetDefaultFrameBackground());
+
+ ~TGLViewerEditor();
+
+ void SetModel(TVirtualPad *pad, TObject *obj, Int_t event);
+ void SetGuides();
+ void SetCurrentClip();
+ //Lights manipulation
+ void DoButton();
+ //Axis manipulation
+ void UpdateViewerGuides();
+ void UpdateReferencePos();
+ //Clipping manipulation
+ void ClipValueChanged();
+ void ClipTypeChanged(Int_t);
+ void UpdateViewerClip();
+
+ ClassDef(TGLViewerEditor, 0) //GUI for editing TGLViewer attributes
+};
+
+#endif
diff --git a/gl/inc/TX11GL.h b/gl/inc/TX11GL.h
index 660a8dcb75a..ef351a13f2b 100644
--- a/gl/inc/TX11GL.h
+++ b/gl/inc/TX11GL.h
@@ -1,4 +1,4 @@
-// @(#)root/x11:$Name: $:$Id: TX11GL.h,v 1.9 2006/02/06 16:15:13 couet Exp $
+// @(#)root/x11:$Name: $:$Id: TX11GL.h,v 1.10 2006/02/07 14:18:45 couet Exp $
// Author: Timur Pocheptsov 09/08/2004
/*************************************************************************
@@ -93,7 +93,10 @@ public:
//used by viewer
void DrawViewer(TVirtualViewer3D *vv);
- TObject* Select(TVirtualViewer3D *vv, Int_t x, Int_t y);
+ //
+ Bool_t SelectViewer(TVirtualViewer3D *viewer, const TGLRect *selRect);
+ Bool_t SelectManip(TVirtualGLManip *manip, const TGLCamera *camera, const TGLRect *rect, const TGLBoundingBox *sceneBox);
+ //
void PaintSingleObject(TVirtualGLPainter *);
void PrintViewer(TVirtualViewer3D *vv);
diff --git a/gl/src/TGLHistPainter.cxx b/gl/src/TGLHistPainter.cxx
index e76ccf11ce8..b91d3c70bd2 100644
--- a/gl/src/TGLHistPainter.cxx
+++ b/gl/src/TGLHistPainter.cxx
@@ -1,4 +1,5 @@
#include <algorithm>
+#include <iostream>
#ifdef WIN32
#include "Windows4root.h"
@@ -22,6 +23,11 @@
#include "TROOT.h"
#include "TAxis.h"
#include "TMath.h"
+#include "TFile.h"
+
+#include "TH2.h"
+
+#include "TGLBoundingBox.h"
#include "TPad.h"
#include "TH1.h"
#include "TF3.h"
@@ -58,7 +64,8 @@ TGLHistPainter::TGLHistPainter(TH1 *hist)
f2DPass(kFALSE),
fTextureName(0),
fCurrentPainter(0),
- fFrontPoint(2)
+ fFrontPoint(2),
+ fZoom(1.)
{
//Each TGLHistPainter has default painter as a member
//to delegate unsupported calls
@@ -89,6 +96,8 @@ Int_t TGLHistPainter::DistancetoPrimitive(Int_t px, Int_t py)
if (!MakeCurrent())return 1000;
+
+
if (!Select(px, py))
gPad->SetSelected(gPad);// To avoid TF2 selection
@@ -143,7 +152,20 @@ void TGLHistPainter::ExecuteEvent(Int_t event, Int_t px, Int_t py)
case kMouseMotion:
gPad->SetCursor(kRotate);//Does not work for TF2 (?)
break;
+ case kButton2Down:
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+ fCurrPos.fX = px;
+ fCurrPos.fY = fViewport[3] - py;
+ break;
+ case kButton2Motion:
+ Pan(px, fViewport[3] - py);
+ break;
+ case kButton2Up:
+ gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
+ break;
case kKeyPress:
+ case 5:
+ case 6:
if (fLastOption == kTF3 && (py == kKey_s || py == kKey_S)) {
if(fTF3Style < kMaple2)
fTF3Style = EGLTF3Style(fTF3Style + 1);
@@ -153,6 +175,18 @@ void TGLHistPainter::ExecuteEvent(Int_t event, Int_t px, Int_t py)
gPad->Modified();
gPad->Update();
}
+ if (event == 5 || py == kKey_J || py == kKey_j) {
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+ fZoom /= 1.2;
+ gGLManager->PaintSingleObject(this);
+ gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
+ } else if (event == 6 || py == kKey_K || py == kKey_k) {
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+ fZoom *= 1.2;
+ gGLManager->PaintSingleObject(this);
+ gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
+ }
+ break;
}
}
}
@@ -281,6 +315,7 @@ void TGLHistPainter::Paint(Option_t *o)
void TGLHistPainter::Paint()
{
//This function indirectly called via gGLManager->PaintSingleObject
+
gPad->SetCopyGLDevice(kTRUE);
//Calculate translation, frustum.
CalculateTransformation();
@@ -318,6 +353,29 @@ void TGLHistPainter::Paint()
DrawAxes();
gVirtualX->SelectWindow(gPad->GetPixmapID());
//Flush pixmap during rotation
+
+ /* gPad->SetCopyGLDevice(kTRUE);
+ glColor3d(1., 0., 0.);
+ glDisable(GL_CULL_FACE);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(-1., 1., -1., 1., -200000., 149999.);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+// glTranslated(0, 0, -15000.);
+ glBegin(GL_POLYGON);
+ glNormal3d(0.,0., 1);
+ glVertex3d(-0.5, -0.5, 150000.);
+ glVertex3d(0.5, -0.5, 150000.);
+ glVertex3d(0.5, 0.5, 150000.);
+ glVertex3d(-0.5, 0.5, 150000.);
+ glEnd();
+
+ glFlush();
+ //Put content of GL buffer into pixmap/DIB
+ gGLManager->ReadGLBuffer(fGLDevice);
+ gGLManager->Flush(fGLDevice);*/
gGLManager->Flush(fGLDevice);
}
@@ -1034,8 +1092,8 @@ void TGLHistPainter::CalculateTransformation()
fFrustum[0] = maxDim;
fFrustum[1] = maxDim;
- fFrustum[2] = maxDim * 0.707;
- fFrustum[3] = 3 * maxDim;
+ fFrustum[2] = -100 * maxDim;
+ fFrustum[3] = 100 * maxDim;
fShift = maxDim * 1.5;
}
@@ -1240,7 +1298,7 @@ void TGLHistPainter::SetCamera()const
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
- glOrtho(-fFrustum[0], fFrustum[0], -fFrustum[1], fFrustum[1], fFrustum[2], fFrustum[3]);
+ glOrtho(-fFrustum[0] * fZoom, fFrustum[0] * fZoom, - fFrustum[1] * fZoom, fFrustum[1] * fZoom, -200000, 200000);//fFrustum[2], fFrustum[3]);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
@@ -1256,6 +1314,7 @@ void TGLHistPainter::SetTransformation()const
glRotated(-45., 0., 1., 0.);
glRotated(-90., 0., 1., 0.);
glRotated(-90., 1., 0., 0.);
+ glTranslated(-fPan[0], -fPan[1], -fPan[2]);
glTranslated(-fCenter[0] * fScaleX, -fCenter[1] * fScaleY, -fCenter[2] * fScaleZ);
}
@@ -1929,7 +1988,9 @@ namespace {
255, 255, 185, 200
};
+
const UChar_t gDefTexture2[] =
+
{
//R G B A
230, 0, 115, 255,
@@ -1951,6 +2012,24 @@ namespace {
};
}
+void TGLHistPainter::Pan(Int_t x, Int_t y)
+{
+ Double_t mvMatrix[16] = {0.};
+ glGetDoublev(GL_MODELVIEW_MATRIX, mvMatrix);
+ Double_t prMatrix[16] = {0.};
+ glGetDoublev(GL_PROJECTION_MATRIX, prMatrix);
+
+ TGLVertex3 start, end;
+ gluUnProject(fCurrPos.fX, fCurrPos.fY, 1., mvMatrix, prMatrix, fViewport, &start.X(), &start.Y(), &start.Z());
+ gluUnProject(x, y, 1., mvMatrix, prMatrix, fViewport, &end.X(), &end.Y(), &end.Z());
+ TGLVector3 delta = start - end;
+ fPan = fPan + delta / 2.;
+ fCurrPos.fX = x, fCurrPos.fY = y;
+// fFrustum[0] *= 1.2, fFrustum[1] *= 1.2;
+ gGLManager->PaintSingleObject(this);
+}
+
+
//______________________________________________________________________________
void TGLHistPainter::SetTexture()
{
diff --git a/gl/src/TGLManip.cxx b/gl/src/TGLManip.cxx
index feaf8ddfb26..f19ef64d305 100644
--- a/gl/src/TGLManip.cxx
+++ b/gl/src/TGLManip.cxx
@@ -1,4 +1,4 @@
-// @(#)root/gl:$Name: $:$Id: TGLManip.cxx,v 1.8 2006/01/30 17:42:06 rdm Exp $
+// @(#)root/gl:$Name: $:$Id: TGLManip.cxx,v 1.9 2006/02/23 16:44:52 brun Exp $
// Author: Richard Maunder 16/09/2005
/*************************************************************************
@@ -151,6 +151,9 @@ Bool_t TGLManip::HandleMotion(const Event_t & event, const TGLCamera & camera, c
// TODO: Again very ugly cross thread gVirtual GL call requires passing viewer
//
+ if (gGLManager)
+ return gGLManager->SelectManip(this, &camera, &selectRect, &sceneBox);
+
return gVirtualGL->SelectManip(this, &camera, &selectRect, &sceneBox);
}
diff --git a/gl/src/TGLPixmap.cxx b/gl/src/TGLPixmap.cxx
deleted file mode 100644
index 41a71cabcff..00000000000
--- a/gl/src/TGLPixmap.cxx
+++ /dev/null
@@ -1,1356 +0,0 @@
-// @(#)root/gl:$Name: $:$Id: TGLPixmap.cxx,v 1.13 2006/02/06 16:15:13 couet Exp $
-// Author: Timur Pocheptsov 18/08/2005
-
-/*************************************************************************
- * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
- * All rights reserved. *
- * *
- * For the licensing terms see $ROOTSYS/LICENSE. *
- * For the list of contributors see $ROOTSYS/README/CREDITS. *
- *************************************************************************/
-
-#include "Riostream.h"
-#include <algorithm>
-#include <utility>
-#include <vector>
-
-#ifdef WIN32
-#include "Windows4root.h"
-#endif
-
-#include <GL/gl.h>
-#include <GL/glu.h>
-
-#include "TVirtualPS.h"
-#include "gl2ps.h"
-#include "TVirtualGL.h"
-#include "TVirtualPad.h"
-#include "TError.h"
-#include "TBuffer3D.h"
-#include "TColor.h"
-#include "TMath.h"
-#include "TSystem.h"
-#include "TGLPixmap.h"
-#include "TArcBall.h"
-#include "TBuffer3D.h"
-#include "TBuffer3DTypes.h"
-#include "TObjArray.h"
-#include "Buttons.h"
-
-#include "TPad.h"
-#include "KeySymbols.h"
-
-ClassImp(TGLPixmap)
-
-class GLSelection {
-private:
- Double_t fBBox[6];
-
-public:
- GLSelection();
- GLSelection(const Double_t *bbox);
- GLSelection(Double_t xmin, Double_t xmax, Double_t ymin,
- Double_t ymax, Double_t zmin, Double_t zmax);
-
- void SetBBox(const Double_t *newBbox);
- void SetBBox(Double_t xmin, Double_t xmax, Double_t ymin,
- Double_t ymax, Double_t zmin, Double_t zmax);
-
- const Double_t *GetRangeX()const{return fBBox;}
- const Double_t *GetRangeY()const{return fBBox + 2;}
- const Double_t *GetRangeZ()const{return fBBox + 4;}
-};
-
-class GLSceneObject : public TObject {
-protected:
- std::vector<Double_t> fVertices;
- Float_t fColor[17];
- GLSelection fSelectionBox;
- Bool_t fIsSelected;
-
-private:
- UInt_t fGLName;
- GLSceneObject *fNextT;
- TObject *fRealObject;
-
-public:
- GLSceneObject(const TBuffer3D &buffer, Int_t verticesReserve,
- const Float_t *color = 0, UInt_t glName = 0, TObject *realObj = 0);
- GLSceneObject(const TBuffer3D &buffer,
- const Float_t *color = 0, UInt_t glName = 0, TObject *realObj = 0);
- GLSceneObject(UInt_t glName, const Float_t *color, Short_t trans, TObject *realObj);
-
- virtual Bool_t IsTransparent()const;
-
- virtual void GLDraw()const = 0;
-
- GLSelection *GetBBox(){return &fSelectionBox;}
- const GLSelection *GetBBox()const{return &fSelectionBox;}
-
- void SetNextT(GLSceneObject *next){fNextT = next;}
- GLSceneObject *GetNextT()const{return fNextT;}
-
- UInt_t GetGLName()const{return fGLName;}
- TObject *GetRealObject()const{return fRealObject;}
-
- const Float_t *GetColor()const{return fColor;}
- void SetColor(const Float_t *newColor, Bool_t fromCtor = kFALSE);
-
- void Select(Bool_t select = kTRUE){fIsSelected = select;}
-
- void SetBBox();
-private:
- GLSceneObject(const GLSceneObject &);
- GLSceneObject & operator = (const GLSceneObject &);
-
- void SetBBox(const TBuffer3D & buffer);
-
-};
-
-class GLFaceSet : public GLSceneObject {
-private:
- std::vector<Double_t> fNormals;
- std::vector<Int_t> fPolyDesc;
- UInt_t fNbPols;
-
-public:
- GLFaceSet(const TBuffer3D &buff, const Float_t *color,
- UInt_t glName, TObject *realObj);
-
- void GLDraw()const;
- void GLDrawPolys()const;
-
-private:
- Int_t CheckPoints(const Int_t *source, Int_t *dest)const;
- static Bool_t Eq(const Double_t *p1, const Double_t *p2);
- void CalculateNormals();
-};
-
-static GLUtriangulatorObj *getTesselator()
-{
- static struct Init {
- Init()
- {
-#if defined(R__WIN32)
- typedef void (CALLBACK *tessfuncptr_t)();
-#elif defined(R__AIXGCC)
- typedef void (*tessfuncptr_t)(...);
-#else
- typedef void (*tessfuncptr_t)();
-#endif
- fTess = gluNewTess();
-
- if (!fTess) {
- Error("getTesselator::Init", "could not create tesselation object");
- } else {
- gluTessCallback(fTess, (GLenum)GLU_BEGIN, (tessfuncptr_t)glBegin);
- gluTessCallback(fTess, (GLenum)GLU_END, (tessfuncptr_t)glEnd);
- gluTessCallback(fTess, (GLenum)GLU_VERTEX, (tessfuncptr_t)glVertex3dv);
- }
- }
- ~Init()
- {
- if(fTess)
- gluDeleteTess(fTess);
- }
- GLUtriangulatorObj *fTess;
- }singleton;
-
- return singleton.fTess;
-}
-
-
-//______________________________________________________________________________
-GLSelection::GLSelection()
-{
- //
- fBBox[0] = fBBox[1] = fBBox[2] =
- fBBox[3] = fBBox[4] = fBBox[5] = 0.;
-}
-
-
-//______________________________________________________________________________
-GLSelection::GLSelection(const Double_t *bbox)
-{
- //
- for (Int_t i= 0; i < 6; ++i) fBBox[i] = bbox[i];
-}
-
-
-//______________________________________________________________________________
-GLSelection::GLSelection(Double_t xmin, Double_t xmax, Double_t ymin,
- Double_t ymax, Double_t zmin, Double_t zmax)
-{
- //
- fBBox[0] = xmin, fBBox[1] = xmax;
- fBBox[2] = ymin, fBBox[3] = ymax;
- fBBox[4] = zmin, fBBox[5] = zmax;
-}
-
-
-//______________________________________________________________________________
-void GLSelection::SetBBox(const Double_t *newBBox)
-{
- //
- for (Int_t i= 0; i < 6; ++i) fBBox[i] = newBBox[i];
-}
-
-
-//______________________________________________________________________________
-void GLSelection::SetBBox(Double_t xmin, Double_t xmax, Double_t ymin,
- Double_t ymax, Double_t zmin, Double_t zmax)
-{
- //
- fBBox[0] = xmin, fBBox[1] = xmax;
- fBBox[2] = ymin, fBBox[3] = ymax;
- fBBox[4] = zmin, fBBox[5] = zmax;
-}
-
-
-//______________________________________________________________________________
-GLSceneObject::GLSceneObject(const TBuffer3D &buffer, const Float_t *color,
- UInt_t glName, TObject *obj) :
- fVertices(buffer.fPnts, buffer.fPnts + 3 * buffer.NbPnts()),
- fColor(),
- fIsSelected(kFALSE),
- fGLName(glName),
- fNextT(0),
- fRealObject(obj)
-{
- //
- SetColor(color, kTRUE);
- fColor[3] = 1.f - buffer.fTransparency / 100.f;
- SetBBox(buffer);
-}
-
-
-//______________________________________________________________________________
-GLSceneObject::GLSceneObject(const TBuffer3D &buffer, Int_t verticesReserve,
- const Float_t *color, UInt_t glName, TObject *obj) :
- fVertices(verticesReserve, 0.),
- fColor(),
- fIsSelected(kFALSE),
- fGLName(glName),
- fNextT(0),
- fRealObject(obj)
-{
- //
- SetColor(color, kTRUE);
- fColor[3] = 1.f - buffer.fTransparency / 100.f;
- SetBBox(buffer);
-}
-
-
-//______________________________________________________________________________
-GLSceneObject::GLSceneObject(UInt_t glName, const Float_t *color, Short_t trans, TObject *obj)
- : fColor(), fIsSelected(kFALSE), fGLName(glName), fNextT(0), fRealObject(obj)
-{
- //
- SetColor(color, kTRUE);
- fColor[3] = 1.f - trans / 100.f;
-}
-
-
-//______________________________________________________________________________
-Bool_t GLSceneObject::IsTransparent()const
-{
- //
- return fColor[3] < 1.f;
-}
-
-
-//______________________________________________________________________________
-void GLSceneObject::SetColor(const Float_t *color, Bool_t fromCtor)
-{
- //
- if (!fromCtor) {
- for (Int_t i = 0; i < 17; ++i) fColor[i] = color[i];
- } else {
- if (color) {
- //diffuse and specular
- fColor[0] = color[0];
- fColor[1] = color[1];
- fColor[2] = color[2];
- } else {
- //for (Int_t i = 0; i < 12; ++i) fColor[i] = 1.f;
- fColor[0] = 1.f;
- fColor[1] = .3f;
- fColor[2] = .0f;
- }
- //ambient
- fColor[4] = fColor[5] = fColor[6] = 0.f;
- //specular
- fColor[8] = fColor[9] = fColor[10] = 0.7f;
- //emission
- fColor[12] = fColor[13] = fColor[14] = 0.f;
- //alpha
- fColor[3] = fColor[7] = fColor[11] = fColor[15] = 1.f;
- //shininess
- if (color) fColor[16] = 60.f;
- else fColor[16] = 10.f;
- }
-}
-
-
-//______________________________________________________________________________
-void GLSceneObject::SetBBox(const TBuffer3D & buffer)
-{
- //
- Double_t xmin = buffer.fPnts[0], xmax = xmin;
- Double_t ymin = buffer.fPnts[1], ymax = ymin;
- Double_t zmin = buffer.fPnts[2], zmax = zmin;
-
- for (UInt_t nv = 3; nv < buffer.NbPnts()*3; nv += 3) {
- xmin = TMath::Min(xmin, buffer.fPnts[nv]);
- xmax = TMath::Max(xmax, buffer.fPnts[nv]);
- ymin = TMath::Min(ymin, buffer.fPnts[nv + 1]);
- ymax = TMath::Max(ymax, buffer.fPnts[nv + 1]);
- zmin = TMath::Min(zmin, buffer.fPnts[nv + 2]);
- zmax = TMath::Max(zmax, buffer.fPnts[nv + 2]);
- }
-
- fSelectionBox.SetBBox(xmin, xmax, ymin, ymax, zmin, zmax);
-}
-
-
-//______________________________________________________________________________
-void GLSceneObject::SetBBox()
-{
- // Use the buffer bounding box if provided
-
- if (fVertices.size() >= 3) {
- Double_t xmin = fVertices[0], xmax = xmin;
- Double_t ymin = fVertices[1], ymax = ymin;
- Double_t zmin = fVertices[2], zmax = zmin;
-
- for (UInt_t nv = 3; nv < fVertices.size(); nv += 3) {
- xmin = TMath::Min(xmin, fVertices[nv]);
- xmax = TMath::Max(xmax, fVertices[nv]);
- ymin = TMath::Min(ymin, fVertices[nv + 1]);
- ymax = TMath::Max(ymax, fVertices[nv + 1]);
- zmin = TMath::Min(zmin, fVertices[nv + 2]);
- zmax = TMath::Max(zmax, fVertices[nv + 2]);
- }
-
- fSelectionBox.SetBBox(xmin, xmax, ymin, ymax, zmin, zmax);
- }
-}
-
-
-//______________________________________________________________________________
-GLFaceSet::GLFaceSet(const TBuffer3D & buff, const Float_t *color, UInt_t glname, TObject *realobj)
- :GLSceneObject(buff, color, glname, realobj),
- fNormals(3 * buff.NbPols())
-{
- //
- fNbPols = buff.NbPols();
-
- Int_t *segs = buff.fSegs;
- Int_t *pols = buff.fPols;
- Int_t shiftInd = buff.fReflection ? 1 : -1;
-
- Int_t descSize = 0;
-
- for (UInt_t i = 0, k = 1; i < fNbPols; ++i, ++k)
- {
- descSize += pols[k] + 1;
- k += pols[k] + 1;
- }
-
- fPolyDesc.resize(descSize);
-
- for (UInt_t numPol = 0, currInd = 0, j = 1; numPol < fNbPols; ++numPol) {
- Int_t segmentInd = shiftInd < 0 ? pols[j] + j : j + 1;
- Int_t segmentCol = pols[j];
- Int_t s1 = pols[segmentInd];
- segmentInd += shiftInd;
- Int_t s2 = pols[segmentInd];
- segmentInd += shiftInd;
- Int_t segEnds[] = {segs[s1 * 3 + 1], segs[s1 * 3 + 2],
- segs[s2 * 3 + 1], segs[s2 * 3 + 2]};
- Int_t numPnts[3] = {0};
-
- if (segEnds[0] == segEnds[2]) {
- numPnts[0] = segEnds[1], numPnts[1] = segEnds[0], numPnts[2] = segEnds[3];
- } else if (segEnds[0] == segEnds[3]) {
- numPnts[0] = segEnds[1], numPnts[1] = segEnds[0], numPnts[2] = segEnds[2];
- } else if (segEnds[1] == segEnds[2]) {
- numPnts[0] = segEnds[0], numPnts[1] = segEnds[1], numPnts[2] = segEnds[3];
- } else {
- numPnts[0] = segEnds[0], numPnts[1] = segEnds[1], numPnts[2] = segEnds[2];
- }
-
- fPolyDesc[currInd] = 3;
- Int_t sizeInd = currInd++;
- fPolyDesc[currInd++] = numPnts[0];
- fPolyDesc[currInd++] = numPnts[1];
- fPolyDesc[currInd++] = numPnts[2];
- Int_t lastAdded = numPnts[2];
-
- Int_t end = shiftInd < 0 ? j + 1 : j + segmentCol;
- for (; segmentInd != end; segmentInd += shiftInd) {
- segEnds[0] = segs[pols[segmentInd] * 3 + 1];
- segEnds[1] = segs[pols[segmentInd] * 3 + 2];
- if (segEnds[0] == lastAdded) {
- fPolyDesc[currInd++] = segEnds[1];
- lastAdded = segEnds[1];
- } else {
- fPolyDesc[currInd++] = segEnds[0];
- lastAdded = segEnds[0];
- }
- ++fPolyDesc[sizeInd];
- }
- j += segmentCol + 2;
- }
-
- CalculateNormals();
-}
-
-
-//______________________________________________________________________________
-void GLFaceSet::GLDraw()const
-{
- //
- static float spec[] = {.4f, .4f, .4f, 1.f};
-
- glMaterialfv(GL_FRONT, GL_DIFFUSE, fColor);
- glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
- glMaterialf(GL_FRONT, GL_SHININESS, 20);
-
- if (IsTransparent()) {
- glEnable(GL_BLEND);
- glDepthMask(GL_FALSE);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- }
-
- glLoadName(GetGLName());
-
- GLDrawPolys();
-
- if (IsTransparent()) {
- glDepthMask(GL_TRUE);
- glDisable(GL_BLEND);
- }
-}
-
-
-//______________________________________________________________________________
-void GLFaceSet::GLDrawPolys()const
-{
- //
- GLUtriangulatorObj *tessObj = getTesselator();
- const Double_t *pnts = &fVertices[0];
- const Double_t *normals = &fNormals[0];
- const Int_t *pols = &fPolyDesc[0];
-
- for (UInt_t i = 0, j = 0; i < fNbPols; ++i) {
- Int_t npoints = pols[j++];
-
- if (tessObj && npoints > 4) {
- gluBeginPolygon(tessObj);
- gluNextContour(tessObj, (GLenum)GLU_UNKNOWN);
- glNormal3dv(normals + i * 3);
-
- for (Int_t k = 0; k < npoints; ++k, ++j) {
- gluTessVertex(tessObj, (Double_t *)pnts + pols[j] * 3, (Double_t *)pnts + pols[j] * 3);
- }
- gluEndPolygon(tessObj);
- } else {
- glBegin(GL_POLYGON);
- glNormal3dv(normals + i * 3);
-
- for (Int_t k = 0; k < npoints; ++k, ++j) {
- glVertex3dv(pnts + pols[j] * 3);
- }
- glEnd();
- }
- }
-}
-
-
-//______________________________________________________________________________
-Int_t GLFaceSet::CheckPoints(const Int_t *source, Int_t *dest) const
-{
- //
- const Double_t * p1 = &fVertices[source[0] * 3];
- const Double_t * p2 = &fVertices[source[1] * 3];
- const Double_t * p3 = &fVertices[source[2] * 3];
- Int_t retVal = 1;
-
- if (Eq(p1, p2)) {
- dest[0] = source[0];
- if (!Eq(p1, p3) ) {
- dest[1] = source[2];
- retVal = 2;
- }
- } else if (Eq(p1, p3)) {
- dest[0] = source[0];
- dest[1] = source[1];
- retVal = 2;
- } else {
- dest[0] = source[0];
- dest[1] = source[1];
- retVal = 2;
- if (!Eq(p2, p3)) {
- dest[2] = source[2];
- retVal = 3;
- }
- }
-
- return retVal;
-}
-
-
-//______________________________________________________________________________
-Bool_t GLFaceSet::Eq(const Double_t *p1, const Double_t *p2)
-{
- //
- Double_t dx = TMath::Abs(p1[0] - p2[0]);
- Double_t dy = TMath::Abs(p1[1] - p2[1]);
- Double_t dz = TMath::Abs(p1[2] - p2[2]);
- return dx < 1e-10 && dy < 1e-10 && dz < 1e-10;
-}
-
-
-//______________________________________________________________________________
-void GLFaceSet::CalculateNormals()
-{
- //
- Double_t *pnts = &fVertices[0];
- for (UInt_t i = 0, j = 0; i < fNbPols; ++i) {
- Int_t polEnd = fPolyDesc[j] + j + 1;
- Int_t norm[] = {fPolyDesc[j + 1], fPolyDesc[j + 2], fPolyDesc[j + 3]};
- j += 4;
- Int_t check = CheckPoints(norm, norm), ngood = check;
- if (check == 3) {
- TMath::Normal2Plane(pnts + norm[0] * 3, pnts + norm[1] * 3,
- pnts + norm[2] * 3, &fNormals[i * 3]);
- j = polEnd;
- continue;
- }
- while (j < (UInt_t)polEnd) {
- norm[ngood++] = fPolyDesc[j++];
- if (ngood == 3) {
- ngood = CheckPoints(norm, norm);
- if (ngood == 3) {
- TMath::Normal2Plane(pnts + norm[0] * 3, pnts + norm[1] * 3,
- pnts + norm[2] * 3, &fNormals[i * 3]);
- j = polEnd;
- break;
- }
- }
- }
- }
-}
-
-class GLCamera : public TObject{
-protected:
- const Double_t *fViewVolume;
- const Int_t *fViewPort;
- Double_t fZoom;
- Bool_t fDrawFrame;
-
-public:
- GLCamera(const Double_t *viewvolume, const Int_t *viewport);
- const Int_t *GetViewport()const
- {
- return fViewPort;
- }
- virtual void TurnOn()const = 0;
- virtual void TurnOn(Int_t x, Int_t y)const = 0;
- void Zoom(Double_t zoom)
- {
- fZoom = zoom;
- }
- void Select()
- {
- fDrawFrame = kTRUE;
- }
-private:
- GLCamera(const GLCamera &);
- GLCamera & operator = (const GLCamera &);
-};
-
-class GLTransformation {
-public:
- virtual ~GLTransformation();
- virtual void Apply()const = 0;
-};
-
-
-class GLSimpleTransform : public GLTransformation {
-private:
- const Double_t *fRotMatrix;
- Double_t fShift;
- //modifications
- const Double_t *fX;
- const Double_t *fY;
- const Double_t *fZ;
-public:
- GLSimpleTransform(const Double_t *rm, Double_t s, const Double_t *x,
- const Double_t *y, const Double_t *z);
- void Apply()const;
-};
-
-class GLPerspectiveCamera : public GLCamera {
-private:
- GLSimpleTransform fTransformation;
-public:
- GLPerspectiveCamera(const Double_t *vv, const Int_t *vp,
- const GLSimpleTransform &tr);
- void TurnOn()const;
- void TurnOn(Int_t x, Int_t y)const;
-};
-
-GLCamera::GLCamera(const Double_t *vv, const Int_t *vp)
- :fViewVolume(vv), fViewPort(vp),
- fZoom(1.), fDrawFrame(kFALSE)
-{
- //
-}
-
-GLTransformation::~GLTransformation()
-{
- //
-}
-
-GLSimpleTransform::GLSimpleTransform(const Double_t *rm, Double_t s, const Double_t *x,
- const Double_t *y, const Double_t *z)
- :fRotMatrix(rm), fShift(s),
- fX(x), fY(y), fZ(z)
-{
- //
-}
-
-void GLSimpleTransform::Apply()const
-{
- //
- glTranslated(0., 0., -fShift);
- glMultMatrixd(fRotMatrix);
- glRotated(-90., 1., 0., 0.);
- glTranslated(-*fX, -*fY, -*fZ);
-}
-
-GLPerspectiveCamera::GLPerspectiveCamera(const Double_t *vv, const Int_t *vp,
- const GLSimpleTransform &tr)
- :GLCamera(vv, vp),
- fTransformation(tr)
-{
- //
-}
-
-void GLPerspectiveCamera::TurnOn()const
-{
- //
- glViewport(fViewPort[0], fViewPort[1], fViewPort[2], fViewPort[3]);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
-
- Double_t frx = fViewVolume[0] * fZoom;
- Double_t fry = fViewVolume[1] * fZoom;
-
- glFrustum(-frx, frx, -fry, fry, fViewVolume[2], fViewVolume[3]);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- fTransformation.Apply();
-}
-
-void GLPerspectiveCamera::TurnOn(Int_t x, Int_t y)const
-{
- //
- gluPickMatrix(x, fViewPort[3] - y, 1., 1., (Int_t *)fViewPort);
- Double_t frx = fViewVolume[0] * fZoom;
- Double_t fry = fViewVolume[1] * fZoom;
-
- glFrustum(-frx, frx, -fry, fry, fViewVolume[2], fViewVolume[3]);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- fTransformation.Apply();
-}
-
-
-class TGLRender {
- friend class TGLPixmap;
-private:
- TObjArray fGLObjects;
- TObjArray fGLCameras;
-
- Bool_t fGLInit;
- Bool_t fAllActive;
- Int_t fActiveCam;
-
- GLSceneObject *fFirstT;
- GLSceneObject *fSelectedObj;
-
-public:
- TGLRender();
- virtual ~TGLRender();
- void Traverse();
- void SetAllActive(){fAllActive = kTRUE;}
- void SetActive(UInt_t cam);
- void AddNewObject(GLSceneObject *newObject);
- void RemoveAllObjects();
- void AddNewCamera(GLCamera *newCamera);
- GLSceneObject *SelectObject(Int_t x, Int_t y, Int_t);
-
- Int_t GetSize()const{return fGLObjects.GetEntriesFast();}
-
-private:
- void DrawScene();
- void DrawAxes();
-
- void Init();
-};
-
-
-//______________________________________________________________________________
-TGLRender::TGLRender()
-{
- //
- fGLObjects.SetOwner(kTRUE);
- fGLCameras.SetOwner(kTRUE);
-
- fGLInit = kFALSE;
- fAllActive = kTRUE;
- fActiveCam = 0;
- fFirstT = 0;
- fSelectedObj = 0;
-}
-
-
-//______________________________________________________________________________
-TGLRender::~TGLRender()
-{
- //
-}
-
-
-//______________________________________________________________________________
-void TGLRender::Traverse()
-{
- //
- if (!fGLInit) {
- fGLInit = kTRUE;
- Init();
- }
-
- Int_t start = 0, end = fGLCameras.GetEntriesFast();
-
- if (end == 0) {
- return;
- }
-
- if (!fAllActive) {
- start = fActiveCam;
- end = start + 1;
- }
-
- for (; start < end; ++start) {
- GLCamera *currCam = (GLCamera *)fGLCameras.At(start);
- currCam->TurnOn();
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- DrawScene();
- }
-}
-
-
-//______________________________________________________________________________
-void TGLRender::SetActive(UInt_t ncam)
-{
- //
- fActiveCam = ncam;
- fAllActive = kFALSE;
-}
-
-
-//______________________________________________________________________________
-void TGLRender::AddNewObject(GLSceneObject *newobject)
-{
- //
- fGLObjects.AddLast(newobject);
-}
-
-
-//______________________________________________________________________________
-void TGLRender::RemoveAllObjects()
-{
- //
- fGLObjects.Delete();
- fSelectedObj = 0;
- assert(fGLObjects.GetEntriesFast() == 0);
-}
-
-
-//______________________________________________________________________________
-void TGLRender::AddNewCamera(GLCamera *newcamera)
-{
- //
- fGLCameras.AddLast(newcamera);
-}
-
-
-//______________________________________________________________________________
-GLSceneObject *TGLRender::SelectObject(Int_t x, Int_t y, Int_t cam)
-{
- //
- GLCamera *actCam = (GLCamera *)fGLCameras.At(cam);
- std::vector<UInt_t>selectBuff(fGLObjects.GetEntriesFast() * 4);
- std::vector<std::pair<UInt_t, Int_t> >objNames;
-
- glSelectBuffer(selectBuff.size(), &selectBuff[0]);
- glRenderMode(GL_SELECT);
- glInitNames();
- glPushName(0);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- actCam->TurnOn(x, y);
-
- DrawScene();
- //glFlush();
-
- Int_t hits = glRenderMode(GL_RENDER);
-
- if (hits < 0) {
- Error("TGLRender::SelectObject", "selection buffer overflow");
- } else if (hits > 0) {
- objNames.resize(hits);
- for (Int_t i = 0; i < hits; ++i) {
- //object's "depth"
- objNames[i].first = selectBuff[i * 4 + 1];
- //object's name
- objNames[i].second = selectBuff[i * 4 + 3];
- }
- std::sort(objNames.begin(), objNames.end());
- UInt_t chosen = 0;
- GLSceneObject *hitObject = 0;
- for (Int_t j = 0; j < hits; ++j) {
- chosen = objNames[j].second;
- hitObject = (GLSceneObject *)fGLObjects.At(chosen);
- if (!hitObject->IsTransparent())
- break;
- }
- if (hitObject->IsTransparent()) {
- chosen = objNames[0].second;
- hitObject = (GLSceneObject *)fGLObjects.At(chosen);
- }
- if (hitObject != fSelectedObj) {
- if (fSelectedObj) fSelectedObj->Select(kFALSE);
- fSelectedObj = hitObject;
- fSelectedObj->Select();
- }
- } else if (fSelectedObj) {
- fSelectedObj->Select(kFALSE);
- fSelectedObj = 0;
- }
-
- return fSelectedObj;
-}
-
-
-//______________________________________________________________________________
-void TGLRender::Init()
-{
- //
- glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
- Float_t lmodelAmb[] = {0.5f, 0.5f, 1.f, 1.f};
- glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodelAmb);
- glEnable(GL_LIGHTING);
- glEnable(GL_DEPTH_TEST);
- glEnable(GL_CULL_FACE);
- glCullFace(GL_BACK);
- glClearDepth(1.);
-}
-
-
-//______________________________________________________________________________
-void TGLRender::DrawScene()
-{
- //
- for (Int_t i = 0, e = fGLObjects.GetEntriesFast(); i < e; ++i) {
- GLSceneObject *currObj = (GLSceneObject *)fGLObjects.At(i);
- if (currObj->IsTransparent()) {
- currObj->SetNextT(fFirstT);
- fFirstT = currObj;
- } else {
- currObj->GLDraw();
- }
- }
-
- while (fFirstT) {
- fFirstT->GLDraw();
- fFirstT = fFirstT->GetNextT();
- }
-}
-
-
-//______________________________________________________________________________
-TGLPixmap::TGLPixmap(TVirtualPad *pad)
- : fCamera(), fViewVolume(), fZoom(),
- fActiveViewport(), fArcBall(100, 100), fBuildingScene(kFALSE),
- fPad(pad), fFirstScene(kTRUE)
-{
- //
- fGLDevice = pad->GetGLDevice();
-
- if (fGLDevice == -1) return;
-
- fLightMask = 0x1b;
- fXc = fYc = fZc = fRad = 0.;
- fPressed = kFALSE;
- fNbShapes = 0;
- fSelectedObj = 0;
- fAction = kNoAction;
-
- CreateViewer();
- CalculateViewports();
- fArcBall.SetBounds(fActiveViewport[2], fActiveViewport[3]);
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::CreateViewer()
-{
- //
- fZoom[0] = fZoom[1] = fZoom[2] = fZoom[3] = 1.;
- fRender = new TGLRender;
-}
-
-
-//______________________________________________________________________________
-TGLPixmap::~TGLPixmap()
-{
- //
- delete fRender;
-}
-
-//______________________________________________________________________________
-void TGLPixmap::DrawObjects()const
-{
- //
- if (!MakeCurrent())return;
-
- const_cast<TGLPixmap *>(this)->CalculateViewports();
- //new MVGL!!!
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- Float_t pos1[] = {0., fRad + fYc, -fRad - fZc, 1.f};
- Float_t pos2[] = {fRad + fXc, 0.f, -fRad - fZc, 1.f};
- Float_t pos3[] = {0.f, -fRad - fYc, -fRad - fZc, 1.f};
- Float_t pos4[] = {-fRad - fXc, 0.f, -fRad - fZc, 1.f};
- Float_t pos5[] = {0.f, 0.f, 0.f, 1.f};
-
- Float_t whiteCol[] = {.7f, .7f, .7f, 1.f};
- glLightfv(GL_LIGHT4, GL_POSITION, pos1);
- glLightfv(GL_LIGHT4, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT1, GL_POSITION, pos2);
- glLightfv(GL_LIGHT1, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT2, GL_POSITION, pos3);
- glLightfv(GL_LIGHT2, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT3, GL_POSITION, pos4);
- glLightfv(GL_LIGHT3, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT0, GL_POSITION, pos5);
- glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteCol);
-
- glEnable(GL_LIGHT4);
- glEnable(GL_LIGHT1);
- glEnable(GL_LIGHT2);
- glEnable(GL_LIGHT3);
- glEnable(GL_LIGHT0);
-
- fRender->Traverse();
-
- glFlush();
- gGLManager->ReadGLBuffer(fGLDevice);
- gGLManager->Flush(fGLDevice);
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::UpdateRange(const GLSelection *box)
-{
- //
- const Double_t *x = box->GetRangeX();
- const Double_t *y = box->GetRangeY();
- const Double_t *z = box->GetRangeZ();
-
- if (!fRender->GetSize()) {
- fRangeX.first = x[0], fRangeX.second = x[1];
- fRangeY.first = y[0], fRangeY.second = y[1];
- fRangeZ.first = z[0], fRangeZ.second = z[1];
- return;
- }
-
- if (fRangeX.first > x[0])
- fRangeX.first = x[0];
- if (fRangeX.second < x[1])
- fRangeX.second = x[1];
- if (fRangeY.first > y[0])
- fRangeY.first = y[0];
- if (fRangeY.second < y[1])
- fRangeY.second = y[1];
- if (fRangeZ.first > z[0])
- fRangeZ.first = z[0];
- if (fRangeZ.second < z[1])
- fRangeZ.second = z[1];
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::PrintObjects()
-{
- // Print objects in a PS file. This function use gl2ps. The gl2ps output
- // is embeded within the TPostScript one.
- if (!MakeCurrent())return;
-
- const_cast<TGLPixmap *>(this)->CalculateViewports();
-
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- Float_t pos1[] = {0., fRad + fYc, -fRad - fZc, 1.f};
- Float_t pos2[] = {fRad + fXc, 0.f, -fRad - fZc, 1.f};
- Float_t pos3[] = {0.f, -fRad - fYc, -fRad - fZc, 1.f};
- Float_t pos4[] = {-fRad - fXc, 0.f, -fRad - fZc, 1.f};
- Float_t pos5[] = {0.f, 0.f, 0.f, 1.f};
-
- Float_t whiteCol[] = {.7f, .7f, .7f, 1.f};
- glLightfv(GL_LIGHT4, GL_POSITION, pos1);
- glLightfv(GL_LIGHT4, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT1, GL_POSITION, pos2);
- glLightfv(GL_LIGHT1, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT2, GL_POSITION, pos3);
- glLightfv(GL_LIGHT2, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT3, GL_POSITION, pos4);
- glLightfv(GL_LIGHT3, GL_DIFFUSE, whiteCol);
- glLightfv(GL_LIGHT0, GL_POSITION, pos5);
- glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteCol);
-
- glEnable(GL_LIGHT4);
- glEnable(GL_LIGHT1);
- glEnable(GL_LIGHT2);
- glEnable(GL_LIGHT3);
- glEnable(GL_LIGHT0);
-
- // Tanslate and scale the PS generated by gl2ps
- gVirtualPS->PrintStr("@");
- gVirtualPS->PrintStr("% Start gl2ps EPS@");
- gVirtualPS->PrintStr("newpath gsave save@");
- Double_t xx[2], yy[2];
- xx[0] = gPad->GetUxmin();
- yy[0] = gPad->GetUymin();
- xx[1] = gPad->GetUxmax();
- yy[1] = gPad->GetUymax();
- gVirtualPS->PrintStr("@");
- gVirtualPS->DrawPS(0, xx, yy);
- gVirtualPS->WriteInteger(4*gPad->GetBorderSize());
- gVirtualPS->PrintStr(" add exch");
- gVirtualPS->WriteInteger(4*gPad->GetBorderSize());
- gVirtualPS->PrintStr(" add exch translate");
- gVirtualPS->PrintStr("@");
- GLint vp[4];
- glGetIntegerv(GL_VIEWPORT,vp);
- gVirtualPS->DrawPS(0, xx, yy);
- gVirtualPS->PrintStr(" exch");
- xx[0] = xx[1];
- yy[0] = yy[1];
- gVirtualPS->DrawPS(0, xx, yy);
- gVirtualPS->PrintStr(" 4 1 roll exch sub 3 1 roll sub");
- gVirtualPS->WriteInteger(2*4*gPad->GetBorderSize());
- gVirtualPS->PrintStr(" sub exch");
- gVirtualPS->WriteInteger(2*4*gPad->GetBorderSize());
- gVirtualPS->PrintStr(" sub exch");
- gVirtualPS->WriteInteger((Int_t)(vp[3]));
- gVirtualPS->WriteInteger((Int_t)(vp[2]));
- gVirtualPS->PrintStr(" 4 1 roll div 3 1 roll exch div exch scale@");
- gVirtualPS->PrintStr("@");
- gVirtualPS->PrintStr("countdictstack@");
- gVirtualPS->PrintStr("mark@");
- gVirtualPS->PrintStr("/showpage {} def@");
-
- // Close the gVirtualPS output stream
- ofstream *fs = (ofstream*)gVirtualPS->GetStream();
- fs->close();
-
- // Generate GL view
- FILE *output = fopen (gVirtualPS->GetName(), "a");
- Int_t gl2psFormat;
- Int_t gl2psSort;
- gl2psFormat = GL2PS_EPS;
- gl2psSort = GL2PS_BSP_SORT;
- Int_t buffsize = 0, state = GL2PS_OVERFLOW;
-
- while (state == GL2PS_OVERFLOW) {
- buffsize += 1024*1024;
- gl2psBeginPage ("ROOT Scene Graph", "ROOT", NULL,
- gl2psFormat, gl2psSort, GL2PS_USE_CURRENT_VIEWPORT
- | GL2PS_POLYGON_OFFSET_FILL | GL2PS_SILENT
- | GL2PS_BEST_ROOT | GL2PS_OCCLUSION_CULL
- | 0,
- GL_RGBA, 0, NULL,0, 0, 0,
- buffsize, output, NULL);
- fRender->Traverse();
- state = gl2psEndPage();
- }
-
- fclose (output);
-
- // Restore the gVirtualPS output stream
- fs = new ofstream(gVirtualPS->GetName(),ios::app);
- gVirtualPS->SetStream(fs);
- gVirtualPS->PrintStr("@");
- gVirtualPS->PrintStr("cleartomark@");
- gVirtualPS->PrintStr("countdictstack exch sub { end } repeat@");
- gVirtualPS->PrintStr("restore grestore@");
- gVirtualPS->PrintStr("% End gl2ps EPS@");
-
- glFlush();
-}
-
-//______________________________________________________________________________
-Bool_t TGLPixmap::MakeCurrent()const
-{
- //
- return fGLDevice != -1 && gGLManager->MakeCurrent(fGLDevice);
-}
-
-//______________________________________________________________________________
-TObject *TGLPixmap::SelectObject(Int_t x, Int_t y)
-{
- // Select Object
- if (!MakeCurrent())return 0;
- CalculateViewvolumes();
-
- Int_t tmpVal = fActiveViewport[1];
- fActiveViewport[1] = 0;
- GLSceneObject *obj = fRender->SelectObject(x, y, 0);
- fActiveViewport[1] = tmpVal;
-
- if (obj) {
- return obj->GetRealObject();
- }
-
- return 0;
-}
-
-
-//______________________________________________________________________________
-Int_t TGLPixmap::DistancetoPrimitive(Int_t x, Int_t y)
-{
- // Compute the disatance to the primitive
-
- TObject *selection = gGLManager->Select(this, x, y);
- if(selection) gPad->SetSelected(selection);
- else gPad->SetSelected(this);
-
- return 0;
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::CalculateViewports()
-{
- //
- gGLManager->ExtractViewport(fGLDevice, fActiveViewport);
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::CalculateViewvolumes()
-{
- //
- CalculateViewports();
-
- if (fRender->GetSize()) {
- Double_t xdiff = fRangeX.second - fRangeX.first;
- Double_t ydiff = fRangeY.second - fRangeY.first;
- Double_t zdiff = fRangeZ.second - fRangeZ.first;
- Double_t max = xdiff > ydiff ? xdiff > zdiff ? xdiff : zdiff : ydiff > zdiff ? ydiff : zdiff;
-
- Double_t frx = 1., fry = 1.;
-
- if (fActiveViewport[2] > fActiveViewport[3])
- frx = fActiveViewport[2] / double(fActiveViewport[3]);
- else if (fActiveViewport[2] < fActiveViewport[3])
- fry = fActiveViewport[3] / double(fActiveViewport[2]);
-
- fViewVolume[0] = max / 1.9 * frx;
- fViewVolume[1] = max / 1.9 * fry;
- fViewVolume[2] = max * 0.707;
- fViewVolume[3] = 3 * max;
- fRad = max * 1.7;
- }
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::CreateCameras()
-{
- //
- if (!fRender->GetSize())
- return;
-
- GLSimpleTransform trPersp(fArcBall.GetRotMatrix(), fRad, &fXc, &fYc, &fZc);
-
- fCamera = new GLPerspectiveCamera(fViewVolume, fActiveViewport, trPersp);
-
- fRender->AddNewCamera(fCamera);
-}
-
-
-//______________________________________________________________________________
-Bool_t TGLPixmap::PreferLocalFrame() const
-{
- // Not at present - but in the future....
- return kFALSE;
-}
-
-void TGLPixmap::BeginScene()
-{
- // Clear any existing scene contents
- fRender->RemoveAllObjects();
- fNbShapes = 0;
- fBuildingScene = kTRUE;
-}
-
-
-//______________________________________________________________________________
-void TGLPixmap::EndScene()
-{
- //
- CalculateViewvolumes();
-
- if (fFirstScene) {
- // Calculate light sources positions
- Double_t xdiff = fRangeX.second - fRangeX.first;
- Double_t ydiff = fRangeY.second - fRangeY.first;
- Double_t zdiff = fRangeZ.second - fRangeZ.first;
-
- fXc = fRangeX.first + xdiff / 2;
- fYc = fRangeY.first + ydiff / 2;
- fZc = fRangeZ.first + zdiff / 2;
-
- CreateCameras();
- fFirstScene = kFALSE;
- }
-
- fBuildingScene = kFALSE;
- gGLManager->DrawViewer(this);
-}
-
-Int_t TGLPixmap::AddObject(const TBuffer3D &buffer, Bool_t *addChildren)
-{
- //
- if (addChildren) {
- *addChildren = kTRUE;
- }
-
- UInt_t reqSections = TBuffer3D::kCore|TBuffer3D::kRawSizes|TBuffer3D::kRaw;
-
- if (!buffer.SectionsValid(reqSections)) {
- return reqSections;
- }
-
- Float_t rgba[] = {.4f, .4f, .4f, 1.f};
- TColor *c = gROOT->GetColor(buffer.fColor);
-
- if (c && buffer.fColor > 1) {
- c->GetRGB(rgba[0], rgba[1], rgba[2]);
- }
-
-
- GLFaceSet *newPix = new GLFaceSet(buffer, rgba, fNbShapes ++, buffer.fID);
- fRender->AddNewObject(newPix);
- UpdateRange(newPix->GetBBox());
-
- return TBuffer3D::kNone;
-}
-
-Bool_t TGLPixmap::OpenComposite(const TBuffer3D &, Bool_t *)
-{
- //
- return kFALSE;
-}
-
-void TGLPixmap::CloseComposite()
-{
- //
-}
-
-void TGLPixmap::AddCompositeOp(UInt_t)
-{
- //
-}
-
-void TGLPixmap::ExecuteEvent(Int_t event, Int_t px, Int_t py)
-{
- //
- py -= Int_t((1 - fPad->GetHNDC() - fPad->GetYlowNDC()) * fPad->GetWh());
- px -= Int_t(fPad->GetXlowNDC() * fPad->GetWw());
- switch(event) {
- case kButton1Down:
- //fix arc ball first
- CalculateViewports();
- fArcBall.SetBounds(fActiveViewport[2], fActiveViewport[3]);
- fArcBall.Click(TPoint(px, py));
- gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
- break;
- case kButton1Up:
- gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
- break;
- case kButton1Motion:
- fArcBall.Drag(TPoint(px, py));
- gGLManager->DrawViewer(this);
- break;
- case kMouseMotion:
- gPad->SetCursor(kRotate);
- break;
- case kKeyPress:
- if (py == kKey_J || py == kKey_j) {
- gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
- fZoom[0] /= 1.2;
- fCamera->Zoom(fZoom[0]);
- gGLManager->DrawViewer(this);
- gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
- } else if (py == kKey_K || py == kKey_k) {
- gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
- fZoom[0] *= 1.2;
- fCamera->Zoom(fZoom[0]);
- gGLManager->DrawViewer(this);
- gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
- }
-
- }
-}
-
-void TGLPixmap::DrawViewer()
-{
- //
- if (!MakeCurrent())return;
- fRender->Init();
-
- Color_t backColor = fPad->GetFillColor();
- Float_t rgb[] = {1.f, 1.f, 1.f};//white will be default
- TColor *c = gROOT->GetColor(backColor);
-
- if (c)
- c->GetRGB(rgb[0], rgb[1], rgb[2]);
-
- glClearColor(rgb[0], rgb[1], rgb[2], 1.f);
-
- DrawObjects();
-}
-
-void TGLPixmap::ZoomIn()
-{
- //
- fZoom[0] /= 2;
- fCamera->Zoom(fZoom[0]);
-}
-
-void TGLPixmap::ZoomOut()
-{
- //
- fZoom[0] *= 2;
- fCamera->Zoom(fZoom[0]);
-}
diff --git a/gl/src/TGLViewer.cxx b/gl/src/TGLViewer.cxx
index 46454765d4e..75ec508f15a 100644
--- a/gl/src/TGLViewer.cxx
+++ b/gl/src/TGLViewer.cxx
@@ -1,4 +1,4 @@
-// @(#)root/gl:$Name: $:$Id: TGLViewer.cxx,v 1.38 2006/02/20 11:02:19 brun Exp $
+// @(#)root/gl:$Name: $:$Id: TGLViewer.cxx,v 1.39 2006/02/23 16:44:52 brun Exp $
// Author: Richard Maunder 25/05/2005
/*************************************************************************
@@ -27,6 +27,7 @@
#include "TGLSphere.h"
#include "TVirtualPad.h" // Remove when pad removed - use signal
+#include "TVirtualX.h"
#include "TColor.h"
#include "TError.h"
@@ -100,7 +101,8 @@ TGLViewer::TGLViewer(TVirtualPad * pad, Int_t x, Int_t y,
fAcceptedPhysicals(0),
fRejectedPhysicals(0),
fIsPrinting(kFALSE),
- fGLWindow(0)
+ fGLWindow(0),
+ fGLDevice(-1)
{
// Construct the viewer object, with following arguments:
// 'pad' - external pad viewer is bound to
@@ -111,6 +113,55 @@ TGLViewer::TGLViewer(TVirtualPad * pad, Int_t x, Int_t y,
SetViewport(x, y, width, height);
}
+//______________________________________________________________________________
+TGLViewer::TGLViewer(TVirtualPad * pad) :
+ fPad(pad),
+ fContextMenu(0),
+ fPerspectiveCameraXOZ(TGLVector3(1.0, 0.0, 0.0), TGLVector3(0.0, 1.0, 0.0)), // XOZ floor
+ fPerspectiveCameraYOZ(TGLVector3(0.0, 1.0, 0.0), TGLVector3(1.0, 0.0, 0.0)), // YOZ floor
+ fPerspectiveCameraXOY(TGLVector3(1.0, 0.0, 0.0), TGLVector3(0.0, 0.0,-1.0)), // XOY floor
+ fOrthoXOYCamera(TGLOrthoCamera::kXOY),
+ fOrthoXOZCamera(TGLOrthoCamera::kXOZ),
+ fOrthoZOYCamera(TGLOrthoCamera::kZOY),
+ fCurrentCamera(&fPerspectiveCameraXOZ),
+ fInternalRebuild(kFALSE),
+ fPostSceneBuildSetup(kTRUE),
+ fAcceptedAllPhysicals(kTRUE),
+ fForceAcceptAll(kFALSE),
+ fInternalPIDs(kFALSE),
+ fNextInternalPID(1), // 0 reserved
+ fComposite(0), fCSLevel(0),
+ fAction(kCameraNone), fLastPos(0,0), fActiveButtonID(0),
+ fDrawFlags(TGLDrawFlags::kFill, TGLDrawFlags::kLODHigh),
+ fRedrawTimer(0),
+ fLightState(kLightMask), // All on
+ fAxesType(kAxesNone),
+ fReferenceOn(kFALSE),
+ fReferencePos(0.0, 0.0, 0.0),
+ fInitGL(kFALSE),
+ fDebugMode(kFALSE),
+ fAcceptedPhysicals(0),
+ fRejectedPhysicals(0),
+ fIsPrinting(kFALSE),
+ fGLWindow(0),
+ fGLDevice(fPad->GetGLDevice())
+{
+ //gl-embedded viewer's ctor
+ // Construct the viewer object, with following arguments:
+ // 'pad' - external pad viewer is bound to
+ // 'x', 'y' - initial top left position
+ // 'width', 'height' - initial width/height
+ // Create timer
+ fRedrawTimer = new TGLRedrawTimer(*this);
+ if (fGLDevice != -1) {
+ Int_t viewport[4] = {0};
+ gGLManager->ExtractViewport(fGLDevice, viewport);
+ SetViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
+ }
+ else
+ Error("TGLViewer", "VAH!!! Dermo kakoe!!!\n");
+}
+
//______________________________________________________________________________
TGLViewer::~TGLViewer()
{
@@ -745,7 +796,7 @@ void TGLViewer::InitGL()
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
- glClearColor(0.0, 0.0, 0.0, 0.0);
+ glClearColor(0.f, 0.f, 0.f, 1.f);
glClearDepth(1.0);
glMaterialf(GL_BACK, GL_SHININESS, 0.0);
glPolygonMode(GL_FRONT, GL_FILL);
@@ -894,10 +945,11 @@ void TGLViewer::RequestDraw(Short_t LOD)
// Post request for redraw of viewer at level of detail 'LOD'
// Request is directed via cross thread gVirtualGL object
fRedrawTimer->Stop();
+// std::cout<<"Draw requested\n";
// Ignore request if GL window or context not yet availible - we
// will get redraw later
- if (!fGLWindow || !gVirtualGL) {
+ if ((!fGLWindow || !gVirtualGL) && fGLDevice == -1) {
return;
}
@@ -912,7 +964,10 @@ void TGLViewer::RequestDraw(Short_t LOD)
return;
}
fDrawFlags.SetLOD(LOD);
- gVirtualGL->DrawViewer(this);
+ if (fGLDevice == -1)
+ gVirtualGL->DrawViewer(this);
+ else
+ gGLManager->DrawViewer(this);
}
//______________________________________________________________________________
@@ -931,6 +986,12 @@ void TGLViewer::DoDraw()
}
fRedrawTimer->Stop();
+
+ if (fGLDevice != -1) {
+ Int_t viewport[4] = {};
+ gGLManager->ExtractViewport(fGLDevice, viewport);
+ SetViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
+ }
TGLStopwatch timer;
if (gDebug>2) {
@@ -1025,6 +1086,18 @@ void TGLViewer::PreDraw()
}
MakeCurrent();
+
+ if (fGLDevice != -1) {
+ //Clear color must be canvas's background color
+ Color_t ci = gPad->GetFillColor();
+ TColor *color = gROOT->GetColor(ci);
+ Float_t sc[3] = {1.f, 1.f, 1.f};
+
+ if (color)
+ color->GetRGB(sc[0], sc[1], sc[2]);
+
+ glClearColor(sc[0], sc[1], sc[2], 1.);
+ }
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -1035,10 +1108,11 @@ void TGLViewer::PreDraw()
void TGLViewer::PostDraw()
{
// Perform GL work which must be done after each draw of scene
+ glFlush();
SwapBuffers();
// Flush everything in case picking starts
- glFlush();
+// glFlush();
TGLUtil::CheckError("TGLViewer::PostDraw");
}
@@ -1047,7 +1121,9 @@ void TGLViewer::PostDraw()
void TGLViewer::MakeCurrent() const
{
// Make GL context current
- fGLWindow->MakeCurrent();
+ if (fGLDevice == -1)
+ fGLWindow->MakeCurrent();
+ else gGLManager->MakeCurrent(fGLDevice);
// Don't call TGLUtil::CheckError() as we do not
// have to be in GL thread here - GL window will call
@@ -1063,7 +1139,13 @@ void TGLViewer::SwapBuffers() const
fScene.CurrentLock() != TGLScene::kSelectLock) {
Error("TGLViewer::SwapBuffers", "scene is %s", TGLScene::LockName(fScene.CurrentLock()));
}
- fGLWindow->SwapBuffers();
+ if (fGLDevice == -1)
+ fGLWindow->SwapBuffers();
+ else {
+ gGLManager->ReadGLBuffer(fGLDevice);
+ gGLManager->Flush(fGLDevice);
+ gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
+ }
}
//______________________________________________________________________________
@@ -1083,7 +1165,10 @@ void TGLViewer::RequestSelect(UInt_t x, UInt_t y)
// TODO: Check only the GUI thread ever enters here & DoSelect.
// Then TVirtualGL and TGLKernel can be obsoleted.
TGLRect selectRect(x, y, 3, 3); // TODO: Constant somewhere
- gVirtualGL->SelectViewer(this, &selectRect);
+ if (fGLDevice == -1)
+ gVirtualGL->SelectViewer(this, &selectRect);
+ else
+ gGLManager->SelectViewer(this, &selectRect);
}
//______________________________________________________________________________
@@ -1133,7 +1218,7 @@ void TGLViewer::SetViewport(Int_t x, Int_t y, UInt_t width, UInt_t height)
{
// Set viewer viewport (window area) with bottom/left at (x,y), with
// dimensions 'width'/'height'
- if (fScene.IsLocked()) {
+ if (fScene.IsLocked() && fGLDevice == -1) {
Error("TGLViewer::SetViewport", "expected kUnlocked, found %s", TGLScene::LockName(fScene.CurrentLock()));
return;
}
@@ -1315,6 +1400,9 @@ void TGLViewer::ToggleLight(ELight light)
}
fLightState ^= light;
+ if (fGLDevice != -1)
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+
RequestDraw();
}
@@ -1356,6 +1444,8 @@ void TGLViewer::SetGuideState(EAxesType axesType, Bool_t referenceOn, const Doub
fAxesType = axesType;
fReferenceOn = referenceOn;
fReferencePos.Set(referencePos[0], referencePos[1], referencePos[2]);
+ if (fGLDevice != -1)
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
RequestDraw();
}
@@ -1462,27 +1552,42 @@ void TGLViewer::ExecuteEvent(Int_t event, Int_t px, Int_t py)
eventSt.fY = py;
switch (event) {
+ case kMouseMotion:
+ eventSt.fCode = kMouseMotion;
+ eventSt.fType = kMotionNotify;
+ HandleMotion(&eventSt);
+ break;
case kButton1Down:
case kButton1Up:
{
eventSt.fCode = kButton1;
- eventSt.fType = kButton1Down ? kButtonPress:kButtonRelease;
+ eventSt.fType = event == kButton1Down ? kButtonPress:kButtonRelease;
HandleButton(&eventSt);
}
+ break;
case kButton2Down:
case kButton2Up:
{
eventSt.fCode = kButton2;
- eventSt.fType = kButton2Down ? kButtonPress:kButtonRelease;
+ eventSt.fType = event == kButton2Down ? kButtonPress:kButtonRelease;
HandleButton(&eventSt);
}
+ break;
case kButton3Down:
+ {
+ eventSt.fState = kKeyShiftMask;
+ eventSt.fCode = kButton1;
+ eventSt.fType = kButtonPress;
+ HandleButton(&eventSt);
+ }
+ break;
case kButton3Up:
{
eventSt.fCode = kButton3;
- eventSt.fType = kButton3Down ? kButtonPress:kButtonRelease;
+ eventSt.fType = kButtonRelease;//event == kButton3Down ? kButtonPress:kButtonRelease;
HandleButton(&eventSt);
}
+ break;
case kButton1Double:
case kButton2Double:
case kButton3Double:
@@ -1491,26 +1596,54 @@ void TGLViewer::ExecuteEvent(Int_t event, Int_t px, Int_t py)
eventSt.fType = kButtonDoubleClick;
HandleDoubleClick(&eventSt);
}
+ break;
case kButton1Motion:
case kButton2Motion:
case kButton3Motion:
{
- eventSt.fCode = kButton1Motion ? kButton1 : kButton2Motion ? kButton2 : kButton3;
+ eventSt.fCode = event == kButton1Motion ? kButton1 : event == kButton2Motion ? kButton2 : kButton3;
eventSt.fType = kMotionNotify;
HandleMotion(&eventSt);
}
+ break;
case kKeyPress: // We only care about full key 'presses' not individual down/up
{
eventSt.fType = kKeyRelease;
- eventSt.fCode = px; // px contains key code - need modifiers from somewhere
+ eventSt.fCode = py; // px contains key code - need modifiers from somewhere
HandleKey(&eventSt);
}
+ break;
+ case 5://trick :)
+ //
+ if (CurrentCamera().Zoom(+50, kFALSE, kFALSE)) { //TODO : val static const somewhere
+ if (fGLDevice != -1) {
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+ gVirtualX->SetDrawMode(TVirtualX::kCopy);
+ }
+ RequestDraw();
+ }
+ break;
+ case 6://trick :)
+ if (CurrentCamera().Zoom(-50, kFALSE, kFALSE)) { //TODO : val static const somewhere
+ if (fGLDevice != -1) {
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+ gVirtualX->SetDrawMode(TVirtualX::kCopy);
+ }
+ RequestDraw();
+ }
+ break;
+ case 7://trick :)
+ eventSt.fState = kKeyShiftMask;
+ eventSt.fCode = kButton1;
+ eventSt.fType = kButtonPress;
+ HandleButton(&eventSt);
+ break;
default:
{
- Error("TGLViewer::ExecuteEvent", "invalid event type");
+ // Error("TGLViewer::ExecuteEvent", "invalid event type");
}
}
-};
+}
//______________________________________________________________________________
Bool_t TGLViewer::HandleEvent(Event_t *event)
@@ -1556,7 +1689,7 @@ Bool_t TGLViewer::HandleButton(Event_t * event)
return kFALSE;
}
}
-
+
// Button DOWN
if (event->fType == kButtonPress) {
Bool_t grabPointer = kFALSE;
@@ -1612,7 +1745,7 @@ Bool_t TGLViewer::HandleButton(Event_t * event)
// Note: Modifiers (ctrl/shift) disabled as fState doesn't seem to
// have correct modifier flags with mouse wheel under Windows..
case(kButton4): {
- // Zoom out (adjust camera FOV)
+ // Zoom out (adjust camera FOV)
if (CurrentCamera().Zoom(+50, kFALSE, kFALSE)) { //TODO : val static const somewhere
RequestDraw();
}
@@ -1627,6 +1760,8 @@ Bool_t TGLViewer::HandleButton(Event_t * event)
}
}
fAction = kCameraNone;
+ if (fGLDevice != -1)
+ gGLManager->MarkForDirectCopy(fGLDevice, kFALSE);
}
return kTRUE;
@@ -1679,11 +1814,14 @@ Bool_t TGLViewer::HandleKey(Event_t *event)
}
return kFALSE;
}
-
+
char tmp[10] = {0};
UInt_t keysym = 0;
- gVirtualX->LookupString(event, tmp, sizeof(tmp), keysym);
+ if (fGLDevice == -1)
+ gVirtualX->LookupString(event, tmp, sizeof(tmp), keysym);
+ else
+ keysym = event->fCode;
Bool_t redraw = kFALSE;
@@ -1755,9 +1893,12 @@ Bool_t TGLViewer::HandleKey(Event_t *event)
Info("OpenGL viewer FORCED rebuild", "");
RebuildScene();
}
+ default:;
}
if (redraw) {
+ if (fGLDevice != -1)
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
RequestDraw();
}
@@ -1786,7 +1927,7 @@ Bool_t TGLViewer::HandleMotion(Event_t * event)
Int_t yDelta = event->fY - fLastPos.fY;
// If no current camera action give to scene to pass on to manipulator
- if (fAction == kNone) {
+ if (fAction == kNone/* && fGLDevice == -1*/) {
MakeCurrent();
processed = fScene.HandleMotion(*event, *fCurrentCamera);
@@ -1807,6 +1948,11 @@ Bool_t TGLViewer::HandleMotion(Event_t * event)
fLastPos.fY = event->fY;
if (processed) {
+ if (fGLDevice != -1) {
+ gGLManager->MarkForDirectCopy(fGLDevice, kTRUE);
+ gVirtualX->SetDrawMode(TVirtualX::kCopy);
+ }
+
RequestDraw();
}
diff --git a/gl/src/TGLViewerEditor.cxx b/gl/src/TGLViewerEditor.cxx
new file mode 100644
index 00000000000..37557048cd9
--- /dev/null
+++ b/gl/src/TGLViewerEditor.cxx
@@ -0,0 +1,448 @@
+#include <iostream>
+#include <cstring>
+
+#include "TGNumberEntry.h"
+#include "TGButtonGroup.h"
+#include "TVirtualGL.h"
+#include "TG3DLine.h"
+#include "TGButton.h"
+#include "TString.h"
+#include "TGLabel.h"
+#include "TClass.h"
+#include "TGTab.h"
+
+#include "TGLViewerEditor.h"
+#include "TGLViewer.h"
+#include "TGLUtil.h"
+
+ClassImp(TGLViewerEditor)
+
+//A lot of raw pointers/naked new-expressions - good way to discredit C++ :(
+//ROOT has system to cleanup - I'll try to use it
+
+//______________________________________________________________________________
+TGLViewerEditor::TGLViewerEditor(const TGWindow *p, Int_t id, Int_t width, Int_t height, UInt_t options, Pixel_t back)
+ : TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ fGuidesTabEl(0),
+ fClipTabEl(0),
+ fGuidesFrame(0),
+ fClipFrame(0),
+ fLightFrame(0),
+ fTopLight(0),
+ fRightLight(0),
+ fBottomLight(0),
+ fLeftLight(0),
+ fFrontLight(0),
+ fAxesContainer(0),
+ fAxesNone(0),
+ fAxesEdge(0),
+ fAxesOrigin(0),
+ fRefContainer(0),
+ fReferenceOn(0),
+ fReferencePosX(0),
+ fReferencePosY(0),
+ fReferencePosZ(0),
+ fCurrentClip(kClipNone),
+ fTypeButtons(0),
+ fPlanePropFrame(0),
+ fPlaneProp(),
+ fBoxPropFrame(0),
+ fBoxProp(),
+ fEdit(0),
+ fApplyButton(0),
+ fViewer(0)
+{
+ //Create tabs
+ CreateLightsTab();
+ CreateGuidesTab();
+ CreateClippingTab();
+
+ fTab->Layout();
+ fTab->MapSubwindows();
+ //Register editor
+ TGedElement *ged = new TGedElement;
+ ged->fGedFrame = this;
+ ged->fCanvas = 0;
+ TGLViewer::Class()->GetEditorList()->Add(ged);
+}
+
+//______________________________________________________________________________
+TGLViewerEditor::~TGLViewerEditor()
+{
+ //Try to cleanup
+ SetCleanup(kDeepCleanup);
+ Cleanup();
+
+ fGuidesFrame->SetCleanup(kDeepCleanup);
+ fGuidesFrame->Cleanup();
+
+ fClipFrame->SetCleanup(kDeepCleanup);
+ fClipFrame->Cleanup();
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::ConnectSignals2Slots()
+{
+ //Connect check buttons
+ //Do I really need this function, or I can connect directly in CreateXXXTab functions ???
+ fTopLight->Connect("Clicked()", "TGLViewerEditor", this, "DoButton()");
+ fRightLight->Connect("Clicked()", "TGLViewerEditor", this, "DoButton()");
+ fBottomLight->Connect("Clicked()", "TGLViewerEditor", this, "DoButton()");
+ fLeftLight->Connect("Clicked()", "TGLViewerEditor", this, "DoButton()");
+ fFrontLight->Connect("Clicked()", "TGLViewerEditor", this, "DoButton()");
+
+ fAxesContainer->Connect("Pressed(Int_t)", "TGLViewerEditor", this, "UpdateViewerGuides()");
+ fReferenceOn->Connect("Clicked()", "TGLViewerEditor", this, "UpdateViewerGuides()");
+ fReferencePosX->Connect("ValueSet(Long_t)", "TGLViewerEditor", this, "UpdateViewerGuides()");
+ fReferencePosY->Connect("ValueSet(Long_t)", "TGLViewerEditor", this, "UpdateViewerGuides()");
+ fReferencePosZ->Connect("ValueSet(Long_t)", "TGLViewerEditor", this, "UpdateViewerGuides()");
+
+ fTypeButtons->Connect("Pressed(Int_t)", "TGLViewerEditor", this, "ClipTypeChanged(Int_t)");
+ fEdit->Connect("Clicked()", "TGLViewerEditor", this, "UpdateViewerClip()");
+
+ for (Int_t i = 0; i < 4; ++i)
+ fPlaneProp[i]->Connect("ValueSet(Long_t)", "TGLViewerEditor", this, "ClipValueChanged()");
+
+ for (Int_t i = 0; i < 6; ++i)
+ fBoxProp[i]->Connect("ValueSet(Long_t)", "TGLViewerEditor", this, "ClipValueChanged()");
+
+ fApplyButton->Connect("Pressed()", "TGLViewerEditor", this, "UpdateViewerClip()");
+
+ fInit = kFALSE;
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::SetModel(TVirtualPad *pad, TObject *obj, Int_t)
+{
+ //Sets model or disables/hides viewer
+ fViewer = 0;
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(TGLViewer::Class())) {
+ SetActive(kFALSE);
+ fGuidesTabEl->UnmapWindow();
+ fGuidesFrame->UnmapWindow();
+ fClipTabEl->UnmapWindow();
+ fClipFrame->UnmapWindow();
+ fTab->SetTab(0);
+ return;
+ } else {
+ fGuidesTabEl->MapWindow();
+ fGuidesFrame->MapWindow();
+ fClipTabEl->MapWindow();
+ fClipFrame->MapWindow();
+ }
+
+ fViewer = static_cast<TGLViewer *>(obj);
+ fModel = obj;
+ fPad = pad;
+ //Set guides controls' values
+ SetGuides();
+ //Set clipping control values
+ SetCurrentClip();
+
+ if (fInit)
+ ConnectSignals2Slots();
+
+ SetActive();
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::DoButton()
+{
+ //Lights radio button was clicked
+ fViewer->ToggleLight(TGLViewer::ELight(((TGButton *) gTQSender)->WidgetId()));
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::UpdateViewerGuides()
+{
+ // Update viewer with GUI state
+ TGLViewer::EAxesType axesType = TGLViewer::kAxesNone;
+
+ for (Int_t i = 1; i < 4; i++) {
+ TGButton * button = fAxesContainer->GetButton(i);
+ if (button && button->IsDown()) {
+ axesType = TGLViewer::EAxesType(i-1);
+ break;
+ }
+ }
+
+ const Double_t refPos[] = {fReferencePosX->GetNumber(), fReferencePosY->GetNumber(), fReferencePosZ->GetNumber()};
+ fViewer->SetGuideState(axesType, fReferenceOn->IsDown(), refPos);
+ UpdateReferencePos();
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::CreateLightsTab()
+{
+ //Creates "Lights" tab
+ fLightFrame = new TGGroupFrame(this, "Light sources:", kLHintsTop | kLHintsCenterX);
+ fLightFrame->SetCleanup(kDeepCleanup);
+ fLightFrame->SetTitlePos(TGGroupFrame::kLeft);
+ AddFrame(fLightFrame, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));//-
+
+ TGMatrixLayout *ml = new TGMatrixLayout(fLightFrame, 0, 1, 10);
+ fLightFrame->SetLayoutManager(ml);
+
+ fTopLight = new TGCheckButton(fLightFrame, "Top", TGLViewer::kLightTop);
+ fTopLight->SetState(kButtonDown);
+ fRightLight = new TGCheckButton(fLightFrame, "Right", TGLViewer::kLightRight);
+ fRightLight->SetState(kButtonDown);
+ fBottomLight = new TGCheckButton(fLightFrame, "Bottom", TGLViewer::kLightBottom);
+ fBottomLight->SetState(kButtonDown);
+ fLeftLight = new TGCheckButton(fLightFrame, "Left", TGLViewer::kLightLeft);
+ fLeftLight->SetState(kButtonDown);
+ fFrontLight = new TGCheckButton(fLightFrame, "Front", TGLViewer::kLightFront);
+ fFrontLight->SetState(kButtonDown);
+
+ fLightFrame->AddFrame(fTopLight);
+ fLightFrame->AddFrame(fRightLight);
+ fLightFrame->AddFrame(fBottomLight);
+ fLightFrame->AddFrame(fLeftLight);
+ fLightFrame->AddFrame(fFrontLight);
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::CreateGuidesTab()
+{
+ //Create "Guides" tab
+ fGuidesFrame = fTab->AddTab("Guides");
+ fGuidesTabEl = fTab->GetTabTab("Guides");
+
+ TGCompositeFrame *nameBin = new TGCompositeFrame(fGuidesFrame, 145, 10, kHorizontalFrame | kFixedWidth | kOwnBackground);
+ nameBin->SetCleanup(kDeepCleanup);
+ nameBin->AddFrame(new TGLabel(nameBin,"Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 5, 0));
+ nameBin->AddFrame(new TGHorizontal3DLine(nameBin), new TGLayoutHints(kLHintsExpandX, 5, 5, 12, 7));
+
+ fGuidesFrame->AddFrame(nameBin, new TGLayoutHints(kLHintsTop, 1, 1, 0, 0));
+ TGLabel *nameLabel = new TGLabel(fGuidesFrame, "TGLViewer::TGLViewer");
+ Pixel_t color;
+ gClient->GetColorByName("#ff0000", color);
+ nameLabel->SetTextColor(color, kFALSE);
+ fGuidesFrame->AddFrame(nameLabel, new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
+
+ fAxesContainer = new TGButtonGroup(fGuidesFrame, "Axes");
+ fAxesContainer->SetCleanup(kDeepCleanup);
+
+ fAxesNone = new TGRadioButton(fAxesContainer, "None");
+ fAxesEdge = new TGRadioButton(fAxesContainer, "Edge");
+ fAxesOrigin = new TGRadioButton(fAxesContainer, "Origin");
+
+ fGuidesFrame->AddFrame(fAxesContainer, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+ //Reference container
+ fRefContainer = new TGGroupFrame(fGuidesFrame, "Reference Marker");
+ fRefContainer->SetCleanup(kDeepCleanup);
+ fGuidesFrame->AddFrame(fRefContainer, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+ //Reference options
+ fReferenceOn = new TGCheckButton(fRefContainer, "Show");
+ fRefContainer->AddFrame(fReferenceOn, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+
+ TGLabel *label = new TGLabel(fRefContainer, "X");
+ fRefContainer->AddFrame(label, new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 0, 3, 3));
+ fReferencePosX = new TGNumberEntry(fRefContainer, 0.0, 8);
+ fRefContainer->AddFrame(fReferencePosX, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+
+ label = new TGLabel(fRefContainer, "Y");
+ fRefContainer->AddFrame(label, new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 0, 3, 3));
+ fReferencePosY = new TGNumberEntry(fRefContainer, 0.0, 8);
+ fRefContainer->AddFrame(fReferencePosY, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+
+ label = new TGLabel(fRefContainer, "Z");
+ fRefContainer->AddFrame(label, new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 0, 3, 3));
+ fReferencePosZ = new TGNumberEntry(fRefContainer, 0.0, 8);
+ fRefContainer->AddFrame(fReferencePosZ, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+}
+
+namespace
+{
+ enum EClippingControlIds {
+ kEditId,
+ kApplyId
+ };
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::CreateClippingTab()
+{
+ // Create GUI controls - clip type (none/plane/box) and plane/box properties
+ fClipFrame = fTab->AddTab("Clipping");
+ fClipTabEl = fTab->GetTabTab("Clipping");
+ //
+ TGCompositeFrame *nameBin = new TGCompositeFrame(fClipFrame, 145, 10, kHorizontalFrame | kFixedWidth | kOwnBackground);
+ nameBin->SetCleanup(kDeepCleanup);
+ nameBin->AddFrame(new TGLabel(nameBin,"Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 5, 0));
+ nameBin->AddFrame(new TGHorizontal3DLine(nameBin), new TGLayoutHints(kLHintsExpandX, 5, 5, 12, 7));
+
+ fClipFrame->AddFrame(nameBin, new TGLayoutHints(kLHintsTop, 1, 1, 0, 0));
+ TGLabel *nameLabel = new TGLabel(fClipFrame, "TGLViewer::TGLViewer");
+ Pixel_t color;
+ gClient->GetColorByName("#ff0000", color);
+ nameLabel->SetTextColor(color, kFALSE);
+ fClipFrame->AddFrame(nameLabel, new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
+
+ fTypeButtons = new TGButtonGroup(fClipFrame, "Clip Type");
+ fTypeButtons->SetCleanup(kDeepCleanup);
+ new TGRadioButton(fTypeButtons, "None");
+ new TGRadioButton(fTypeButtons, "Plane");
+ new TGRadioButton(fTypeButtons, "Box");
+
+ fClipFrame->AddFrame(fTypeButtons, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+ // Viewer Edit
+ fEdit = new TGCheckButton(fClipFrame, "Show / Edit In Viewer", kEditId);
+ fClipFrame->AddFrame(fEdit, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+
+ // Plane properties
+ fPlanePropFrame = new TGCompositeFrame(fClipFrame);
+ fPlanePropFrame->SetCleanup(kDeepCleanup);
+ fClipFrame->AddFrame(fPlanePropFrame, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+
+ static const char * const planeStr[] = { "aX + ", "bY +", "cZ + ", "d = 0" };
+
+ for (Int_t i = 0; i < 4; ++i) {
+ TGLabel *label = new TGLabel(fPlanePropFrame, planeStr[i]);
+ fPlanePropFrame->AddFrame(label, new TGLayoutHints(kLHintsTop | kLHintsLeft, 3, 3, 3, 3));
+ fPlaneProp[i] = new TGNumberEntry(fPlanePropFrame, 1., 8);
+ fPlanePropFrame->AddFrame(fPlaneProp[i], new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+ }
+
+ // Box properties
+ fBoxPropFrame = new TGCompositeFrame(fClipFrame);
+ fBoxPropFrame->SetCleanup(kDeepCleanup);
+ fClipFrame->AddFrame(fBoxPropFrame, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+
+ static const char * const boxStr[] = {"Center X", "Center Y", "Center Z", "Length X", "Length Y", "Length Z" };
+
+ for (Int_t i = 0; i < 6; ++i) {
+ TGLabel *label = new TGLabel(fBoxPropFrame, boxStr[i]);
+ fBoxPropFrame->AddFrame(label, new TGLayoutHints(kLHintsTop | kLHintsLeft, 3, 3, 3, 3));
+ fBoxProp[i] = new TGNumberEntry(fBoxPropFrame, 1., 8);
+ fBoxPropFrame->AddFrame(fBoxProp[i], new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+ }
+
+ // Apply button
+ fApplyButton = new TGTextButton(fClipFrame, "Apply", kApplyId);
+ fClipFrame->AddFrame(fApplyButton, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::UpdateReferencePos()
+{
+ // Enable/disable reference position (x/y/z) number edits based on
+ // reference check box
+ fReferencePosX->SetState(fReferenceOn->IsDown());
+ fReferencePosY->SetState(fReferenceOn->IsDown());
+ fReferencePosZ->SetState(fReferenceOn->IsDown());
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::ClipValueChanged()
+{
+ //One of number edtries was changed
+ fApplyButton->SetState(kButtonUp);
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::ClipTypeChanged(Int_t id)
+{
+ // Clip type radio button changed - update viewer
+ if (id == 1) {
+ fCurrentClip = kClipNone;
+ fViewer->SetCurrentClip(kClipNone, kFALSE);
+ SetCurrentClip();
+ fEdit->SetState(kButtonDisabled);
+ } else {
+ fEdit->SetState(kButtonUp);
+ fCurrentClip = id == 2 ? kClipPlane : kClipBox;
+ fViewer->SetCurrentClip(fCurrentClip, fEdit->IsDown());
+ SetCurrentClip();
+ }
+
+ // Internal GUI change - need to update the viewer
+ gGLManager->MarkForDirectCopy(fViewer->GetDev(), kTRUE);
+ fViewer->RequestDraw();
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::UpdateViewerClip()
+{
+ //Change clipping volume
+ Double_t data[6] = {0.};
+
+ // Fetch GUI state for clip if 'type' into 'data' vector
+ if (fCurrentClip == kClipPlane)
+ for (Int_t i = 0; i < 4; ++i)
+ data[i] = fPlaneProp[i]->GetNumber();
+ else if (fCurrentClip == kClipBox)
+ for (Int_t i = 0; i < 6; ++i)
+ data[i] = fBoxProp[i]->GetNumber();
+
+ fApplyButton->SetState(kButtonDisabled);
+ fViewer->SetClipState(fCurrentClip, data);
+ fViewer->SetCurrentClip(fCurrentClip, fEdit->IsDown());
+ gGLManager->MarkForDirectCopy(fViewer->GetDev(), kTRUE);
+ fViewer->RequestDraw();
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::SetCurrentClip()
+{
+ // Set current (active) GUI clip type from 'type'
+ Bool_t edit = kFALSE;
+ fViewer->GetCurrentClip(fCurrentClip, edit);
+ fEdit->SetDown(edit);
+ fApplyButton->SetState(kButtonDisabled);
+
+ switch(fCurrentClip) {
+ case(kClipNone):
+ fTypeButtons->SetButton(1);
+ fClipFrame->HideFrame(fPlanePropFrame);
+ fClipFrame->HideFrame(fBoxPropFrame);
+ return;
+ case(kClipPlane):
+ fTypeButtons->SetButton(2);
+ fClipFrame->ShowFrame(fPlanePropFrame);
+ fClipFrame->HideFrame(fBoxPropFrame);
+ break;
+ case(kClipBox):
+ fTypeButtons->SetButton(3);
+ fClipFrame->HideFrame(fPlanePropFrame);
+ fClipFrame->ShowFrame(fBoxPropFrame);
+ break;
+ default:;
+ }
+
+ Double_t clip[6] = {0.};
+ fViewer->GetClipState(fCurrentClip, clip);
+
+ if (fCurrentClip == kClipPlane)
+ for (Int_t i = 0; i < 4; ++i)
+ fPlaneProp[i]->SetNumber(clip[i]);
+ else if (fCurrentClip == kClipBox)
+ for (Int_t i = 0; i < 6; ++i)
+ fBoxProp[i]->SetNumber(clip[i]);
+
+ gGLManager->MarkForDirectCopy(fViewer->GetDev(), kTRUE);
+ fViewer->RequestDraw();
+}
+
+//______________________________________________________________________________
+void TGLViewerEditor::SetGuides()
+{
+ //Set cintriks in "Guides" tab
+ TGLViewer::EAxesType axesType = TGLViewer::kAxesNone;
+ Bool_t referenceOn = kFALSE;
+ Double_t referencePos[3] = {0.};
+ fViewer->GetGuideState(axesType, referenceOn, referencePos);
+
+ // Button ids run from 1
+ if (TGButton *btn = fAxesContainer->GetButton(axesType+1))
+ btn->SetDown();
+
+ fReferenceOn->SetDown(referenceOn);
+ fReferencePosX->SetNumber(referencePos[0]);
+ fReferencePosY->SetNumber(referencePos[1]);
+ fReferencePosZ->SetNumber(referencePos[2]);
+ UpdateReferencePos();
+}
diff --git a/gl/src/TX11GL.cxx b/gl/src/TX11GL.cxx
index 280ab4fd79f..0b5cdddf3cd 100644
--- a/gl/src/TX11GL.cxx
+++ b/gl/src/TX11GL.cxx
@@ -1,4 +1,4 @@
-// @(#)root/gx11:$Name: $:$Id: TX11GL.cxx,v 1.13 2006/02/06 16:15:13 couet Exp $
+// @(#)root/gx11:$Name: $:$Id: TX11GL.cxx,v 1.14 2006/02/07 14:18:46 couet Exp $
// Author: Timur Pocheptsov (TX11GLManager) / Valeriy Onuchin (TX11GL)
/*************************************************************************
@@ -21,6 +21,8 @@
#include "TVirtualViewer3D.h"
#include "TVirtualX.h"
+#include "TGLViewer.h"
+#include "TGLManip.h"
#include "TX11GL.h"
#include "TError.h"
#include "TROOT.h"
@@ -556,12 +558,14 @@ void TX11GLManager::DeleteGLContext(Int_t ctxInd)
ctx.fWindowIndex = ctxInd;
}
+//______________________________________________________________________________
Int_t TX11GLManager::GetVirtualXInd(Int_t ctxInd)
{
//Returns index appropriate for gVirtualX
return fPimpl->fGLContexts[ctxInd].fPixmapIndex;
}
+//______________________________________________________________________________
void TX11GLManager::ExtractViewport(Int_t ctxInd, Int_t *viewport)
{
//Returns current sizes of gl pixmap
@@ -576,28 +580,32 @@ void TX11GLManager::ExtractViewport(Int_t ctxInd, Int_t *viewport)
}
//______________________________________________________________________________
-void TX11GLManager::DrawViewer(TVirtualViewer3D *vv)
+void TX11GLManager::PaintSingleObject(TVirtualGLPainter *p)
{
//
- vv->DrawViewer();
+ p->Paint();
}
-//______________________________________________________________________________
-TObject *TX11GLManager::Select(TVirtualViewer3D *vv, Int_t x, Int_t y)
+void TX11GLManager::PrintViewer(TVirtualViewer3D *vv)
{
//
- return vv->SelectObject(x, y);
+ vv->PrintObjects();
}
//______________________________________________________________________________
-void TX11GLManager::PaintSingleObject(TVirtualGLPainter *p)
+void TX11GLManager::DrawViewer(TVirtualViewer3D *viewer)
{
- //
- p->Paint();
+ viewer->DoDraw();
}
-void TX11GLManager::PrintViewer(TVirtualViewer3D *vv)
+//______________________________________________________________________________
+Bool_t TX11GLManager::SelectViewer(TVirtualViewer3D *viewer, const TGLRect *rect)
{
- //
- vv->PrintObjects();
+ return viewer->DoSelect(*rect);
+}
+
+//______________________________________________________________________________
+Bool_t TX11GLManager::SelectManip(TVirtualGLManip *manip, const TGLCamera * camera, const TGLRect * rect, const TGLBoundingBox * sceneBox)
+{
+ return manip->Select(*camera, *rect, *sceneBox);
}
diff --git a/gpad/src/TCanvas.cxx b/gpad/src/TCanvas.cxx
index 26f727f34be..95da414449c 100644
--- a/gpad/src/TCanvas.cxx
+++ b/gpad/src/TCanvas.cxx
@@ -1,4 +1,4 @@
-// @(#)root/gpad:$Name: $:$Id: TCanvas.cxx,v 1.102 2005/11/24 23:30:05 rdm Exp $
+// @(#)root/gpad:$Name: $:$Id: TCanvas.cxx,v 1.103 2005/11/28 13:50:41 brun Exp $
// Author: Rene Brun 12/12/94
/*************************************************************************
@@ -1158,13 +1158,21 @@ void TCanvas::HandleInput(EEventType event, Int_t px, Int_t py)
while ((tc = (TCanvas *)next()))
tc->Update();
}
+
+ if (pad->GetGLDevice() != -1)
+ fSelected->ExecuteEvent(event, px, py);
break; // don't want fPadSave->cd() to be executed at the end
case kButton2Motion:
- break;
-
+ //was empty!
case kButton2Up:
+ if (fSelected) {
+ gPad = fSelectedPad;
+
+ fSelected->ExecuteEvent(event, px, py);
+ RunAutoExec();
+ }
break;
case kButton2Double:
@@ -1196,22 +1204,40 @@ void TCanvas::HandleInput(EEventType event, Int_t px, Int_t py)
break;
case kKeyPress:
+ if (!fSelectedPad || !fSelected) return;
+ gPad = fSelectedPad; // don't use cd() because we won't draw in pad
+ // we will only use its coordinate system
+ fSelected->ExecuteEvent(event, px, py);
- // find pad in which input occured
+ RunAutoExec();
+
+ break;
+ case 7:
+ // Try to select
pad = Pick(px, py, prevSelObj);
+
if (!pad) return;
- gPad = pad; // don't use cd() because we won't draw in pad
- // we will only use its coordinate system
+ EnterLeave(prevSelPad, prevSelObj);
+ gPad = pad; // don't use cd() we will use the current
+ // canvas via the GetCanvas member and not via
+ // gPad->GetCanvas
fSelected->ExecuteEvent(event, px, py);
-
RunAutoExec();
break;
-
default:
- break;
+ //kButton4/kButton5 for embedded gl/ glhistpainter
+ //5 and 6
+ if (event == 5 || event == 6)
+ {
+ pad = Pick(px, py, prevSelObj);
+ if (!pad) return;
+
+ gPad = pad;
+ fSelected->ExecuteEvent(event, px, py);
+ }
}
if (fPadSave && event != kButton2Down)
diff --git a/gui/src/TRootCanvas.cxx b/gui/src/TRootCanvas.cxx
index b3ae6c99039..ff14bb13d2b 100644
--- a/gui/src/TRootCanvas.cxx
+++ b/gui/src/TRootCanvas.cxx
@@ -1,4 +1,4 @@
-// @(#)root/gui:$Name: $:$Id: TRootCanvas.cxx,v 1.91 2006/01/10 09:24:59 brun Exp $
+// @(#)root/gui:$Name: $:$Id: TRootCanvas.cxx,v 1.92 2006/02/06 16:46:41 antcheva Exp $
// Author: Fons Rademakers 15/01/98
/*************************************************************************
@@ -274,13 +274,13 @@ Bool_t TRootContainer::HandleButton(Event_t *event)
newpos = y - page;
if (newpos < 0) newpos = 0;
fCanvas->fCanvasWindow->SetVsbPosition(newpos);
- return kTRUE;
+// return kTRUE;
}
if (event->fCode == kButton5) {
// scroll down
newpos = fCanvas->fCanvasWindow->GetVsbPosition() + page;
fCanvas->fCanvasWindow->SetVsbPosition(newpos);
- return kTRUE;
+// return kTRUE;
}
return fCanvas->HandleContainerButton(event);
}
@@ -1321,7 +1321,6 @@ void TRootCanvas::ShowStatusBar(Bool_t show)
void TRootCanvas::ShowEditor(Bool_t show)
{
// Show or hide side frame.
-
TVirtualPad *savedPad = 0;
savedPad = (TVirtualPad *) gPad;
gPad = Canvas();
@@ -1490,8 +1489,12 @@ Bool_t TRootCanvas::HandleContainerButton(Event_t *event)
if (event->fType == kButtonPress) {
fButton = button;
- if (button == kButton1)
- fCanvas->HandleInput(kButton1Down, x, y);
+ if (button == kButton1) {
+ if (event->fState & kKeyShiftMask)
+ fCanvas->HandleInput(EEventType(7), x, y);
+ else
+ fCanvas->HandleInput(kButton1Down, x, y);
+ }
if (button == kButton2)
fCanvas->HandleInput(kButton2Down, x, y);
if (button == kButton3) {
@@ -1500,6 +1503,10 @@ Bool_t TRootCanvas::HandleContainerButton(Event_t *event)
}
} else if (event->fType == kButtonRelease) {
+ if (button == kButton4)
+ fCanvas->HandleInput(EEventType(5), x, y);//hack
+ if (button == kButton5)
+ fCanvas->HandleInput(EEventType(6), x, y);//hack
if (button == kButton1)
fCanvas->HandleInput(kButton1Up, x, y);
if (button == kButton2)
@@ -1585,6 +1592,8 @@ Bool_t TRootCanvas::HandleContainerMotion(Event_t *event)
fCanvas->HandleInput(kMouseMotion, x, y);
if (fButton == kButton1)
fCanvas->HandleInput(kButton1Motion, x, y);
+ if (fButton == kButton2)
+ fCanvas->HandleInput(kButton2Motion, x, y);
return kTRUE;
}
diff --git a/tutorials/rootgeom.C b/tutorials/rootgeom.C
index 6106e603cf4..1d029e4278f 100644
--- a/tutorials/rootgeom.C
+++ b/tutorials/rootgeom.C
@@ -1,6 +1,7 @@
void rootgeom()
{
//--- Definition of a simple geometry
+// gStyle->SetCanvasPreferGL(true);
gSystem->Load("libGeom");
TGeoManager *geom = new TGeoManager("simple1", "Simple geometry");
@@ -128,6 +129,6 @@ void rootgeom()
//#Viewer3D.DefaultDrawOption: ogl
geom->SetVisLevel(4);
- top->Draw();
+ top->Draw("ogle");
}
diff --git a/win32gdk/inc/TGWin32GL.h b/win32gdk/inc/TGWin32GL.h
index 934eeb462a0..4e9c7a879a5 100644
--- a/win32gdk/inc/TGWin32GL.h
+++ b/win32gdk/inc/TGWin32GL.h
@@ -1,4 +1,4 @@
-// @(#)root/win32gdk:$Name: $:$Id: TGWin32GL.h,v 1.7 2006/01/12 16:56:08 couet Exp $
+// @(#)root/win32gdk:$Name: $:$Id: TGWin32GL.h,v 1.8 2006/02/06 16:48:12 couet Exp $
// Author: Valeriy Onuchin 05/08/04
/*************************************************************************
@@ -86,8 +86,10 @@ public:
//functions to switch between threads in win32
//used by viewer
- void DrawViewer(TVirtualViewer3D *vv);
- TObject* Select(TVirtualViewer3D *vv, Int_t x, Int_t y);
+ void DrawViewer(TVirtualViewer3D *glv);
+ Bool_t SelectViewer(TVirtualViewer3D *viewer, const TGLRect *selRect);
+ Bool_t SelectManip(TVirtualGLManip *manip, const TGLCamera *camera, const TGLRect *rect, const TGLBoundingBox *sceneBox);
+
void PaintSingleObject(TVirtualGLPainter *);
void PrintViewer(TVirtualViewer3D *vv);
diff --git a/win32gdk/inc/TGWin32VirtualGLProxy.h b/win32gdk/inc/TGWin32VirtualGLProxy.h
index 9393a77105e..ab489dcf24f 100644
--- a/win32gdk/inc/TGWin32VirtualGLProxy.h
+++ b/win32gdk/inc/TGWin32VirtualGLProxy.h
@@ -1,4 +1,4 @@
-// @(#)root/win32gdk:$Name: $:$Id: TGWin32VirtualGLProxy.h,v 1.15 2006/01/26 11:59:42 brun Exp $
+// @(#)root/win32gdk:$Name: $:$Id: TGWin32VirtualGLProxy.h,v 1.16 2006/02/06 16:48:12 couet Exp $
// Author: Valeriy Onuchin 05/08/04
/*************************************************************************
@@ -147,7 +147,8 @@ public:
void Flush(Int_t ctxInd);
void DeleteGLContext(Int_t devInd);
void DrawViewer(TVirtualViewer3D *vv);
- TObject* Select(TVirtualViewer3D *vv, Int_t x, Int_t y);
+ Bool_t SelectViewer(TVirtualViewer3D *viewer, const TGLRect *selRect);
+ Bool_t SelectManip(TVirtualGLManip *manip, const TGLCamera *camera, const TGLRect *rect, const TGLBoundingBox *sceneBox);
void PaintSingleObject(TVirtualGLPainter *);
void PrintViewer(TVirtualViewer3D *vv);
diff --git a/win32gdk/src/TGWin32GL.cxx b/win32gdk/src/TGWin32GL.cxx
index 26a95a34c47..219ef64ddb2 100644
--- a/win32gdk/src/TGWin32GL.cxx
+++ b/win32gdk/src/TGWin32GL.cxx
@@ -1,4 +1,4 @@
-// @(#)root/win32gdk:$Name: $:$Id: TGWin32GL.cxx,v 1.9 2005/11/17 14:43:17 couet Exp $
+// @(#)root/win32gdk:$Name: $:$Id: TGWin32GL.cxx,v 1.10 2006/02/06 16:48:12 couet Exp $
// Author: Valeriy Onuchin(TGWin32GL)/ Timur Pocheptsov (TGWin32GLManager)
/*************************************************************************
@@ -587,25 +587,31 @@ void TGWin32GLManager::ExtractViewport(Int_t ctxInd, Int_t *viewport)
}
//______________________________________________________________________________
-void TGWin32GLManager::DrawViewer(TVirtualViewer3D *vv)
+void TGWin32GLManager::PaintSingleObject(TVirtualGLPainter *p)
{
- vv->DrawViewer();
+ p->Paint();
}
//______________________________________________________________________________
-TObject *TGWin32GLManager::Select(TVirtualViewer3D *vv, Int_t x, Int_t y)
+void TGWin32GLManager::PrintViewer(TVirtualViewer3D *vv)
{
- return vv->SelectObject(x, y);
+ vv->PrintObjects();
}
//______________________________________________________________________________
-void TGWin32GLManager::PaintSingleObject(TVirtualGLPainter *p)
+void TGWin32GLManager::DrawViewer(TVirtualViewer3D *viewer)
{
- p->Paint();
+ viewer->DoDraw();
}
//______________________________________________________________________________
-void TGWin32GLManager::PrintViewer(TVirtualViewer3D *vv)
+Bool_t TGWin32GLManager::SelectViewer(TVirtualViewer3D *viewer, const TGLRect *rect)
{
- vv->PrintObjects();
-}
\ No newline at end of file
+ return viewer->DoSelect(*rect);
+}
+
+//______________________________________________________________________________
+Bool_t TGWin32GLManager::SelectManip(TVirtualGLManip *manip, const TGLCamera * camera, const TGLRect * rect, const TGLBoundingBox * sceneBox)
+{
+ return manip->Select(*camera, *rect, *sceneBox);
+}
diff --git a/win32gdk/src/TGWin32VirtualGLProxy.cxx b/win32gdk/src/TGWin32VirtualGLProxy.cxx
index 97f31fa0108..9836ba0acff 100644
--- a/win32gdk/src/TGWin32VirtualGLProxy.cxx
+++ b/win32gdk/src/TGWin32VirtualGLProxy.cxx
@@ -1,4 +1,4 @@
-// @(#)root/win32gdk:$Name: $:$Id: TGWin32VirtualGLProxy.cxx,v 1.17 2006/01/26 11:59:42 brun Exp $
+// @(#)root/win32gdk:$Name: $:$Id: TGWin32VirtualGLProxy.cxx,v 1.18 2006/02/06 16:48:12 couet Exp $
// Author: Valeriy Onuchin 05/08/04
/*************************************************************************
@@ -152,5 +152,6 @@ VOID_METHOD_ARG2(GLManager, ExtractViewport, Int_t, pixInd, Int_t *, vp, 1)
VOID_METHOD_ARG1(GLManager, DrawViewer, TVirtualViewer3D *, vv, 1)
VOID_METHOD_ARG1(GLManager, PrintViewer, TVirtualViewer3D *, vv, 1)
VOID_METHOD_ARG1(GLManager, PaintSingleObject, TVirtualGLPainter *, p, 1)
-RETURN_METHOD_ARG3(GLManager, TObject *, Select, TVirtualViewer3D *, w, Int_t, x, Int_t, y)
+RETURN_METHOD_ARG2(GLManager, Bool_t, SelectViewer, TVirtualViewer3D *, viewer, const TGLRect *, rect)
+RETURN_METHOD_ARG4(GLManager, Bool_t, SelectManip, TVirtualGLManip *, manip, const TGLCamera *, camera, const TGLRect *, rect, const TGLBoundingBox *, box)
--
GitLab