projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0025363: Visualization - add test command for V3d_View::FitAll by view area
[occt.git] / src / ViewerTest / ViewerTest_ViewerCommands.cxx
CommitLineData
b311480e 1// Created on: 1998-09-01
2// Created by: Robert COUBLANC
3// Copyright (c) 1998-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 8// This library is free software; you can redistribute it and/or modify it under
9// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
b311480e 16
58655684 17#include <OpenGl_GlCore20.hxx>
0a768f56 18#include <AIS_Shape.hxx>
19#include <AIS_Drawer.hxx>
20#include <AIS_InteractiveObject.hxx>
21#include <AIS_ListOfInteractive.hxx>
22#include <AIS_ListIteratorOfListOfInteractive.hxx>
23#include <DBRep.hxx>
2bd4c032 24#include <Graphic3d_AspectMarker3d.hxx>
7fd59977 25#include <Graphic3d_ExportFormat.hxx>
269294d6 26#include <Graphic3d_NameOfTextureEnv.hxx>
27#include <Graphic3d_TextureEnv.hxx>
28#include <Graphic3d_TextureParams.hxx>
29#include <Graphic3d_TypeOfTextureFilter.hxx>
4269bd1b 30#include <Graphic3d_AspectFillArea3d.hxx>
7fd59977 31#include <ViewerTest.hxx>
8625ef7e 32#include <ViewerTest_AutoUpdater.hxx>
7fd59977 33#include <ViewerTest_EventManager.hxx>
4754e164 34#include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
4269bd1b 35#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
7fd59977 36#include <Visual3d_View.hxx>
25289ec1 37#include <Visual3d_ViewManager.hxx>
12381341 38#include <V3d_AmbientLight.hxx>
39#include <V3d_DirectionalLight.hxx>
25289ec1 40#include <V3d_LayerMgr.hxx>
12381341 41#include <V3d_LayerMgrPointer.hxx>
42#include <V3d_PositionalLight.hxx>
43#include <V3d_SpotLight.hxx>
18d715bd 44#include <NCollection_DoubleMap.hxx>
45#include <NCollection_List.hxx>
46#include <NCollection_Vector.hxx>
7fd59977 47#include <NIS_View.hxx>
48#include <NIS_Triangulated.hxx>
49#include <NIS_InteractiveContext.hxx>
50#include <AIS_InteractiveContext.hxx>
51#include <Draw_Interpretor.hxx>
52#include <Draw.hxx>
53#include <Draw_Appli.hxx>
7edf74fd 54#include <Aspect_PrintAlgo.hxx>
692613e5 55#include <Image_AlienPixMap.hxx>
58655684 56#include <OpenGl_GraphicDriver.hxx>
208e6839 57#include <OSD_Timer.hxx>
900f7229 58#include <TColStd_HSequenceOfAsciiString.hxx>
59f45b7c 59#include <TColStd_SequenceOfInteger.hxx>
4754e164 60#include <TColStd_HSequenceOfReal.hxx>
61#include <TColgp_Array1OfPnt2d.hxx>
197ac94e 62#include <TColStd_MapOfAsciiString.hxx>
20637bd2 63#include <Visual3d_LayerItem.hxx>
20637bd2 64#include <Aspect_TypeOfLine.hxx>
692613e5 65#include <Image_Diff.hxx>
dc3fe572 66#include <Aspect_DisplayConnection.hxx>
4269bd1b 67#include <gp_Pnt.hxx>
68#include <gp_Dir.hxx>
69#include <gp_Pln.hxx>
70#include <PrsMgr_PresentableObject.hxx>
71#include <Graphic3d_ClipPlane.hxx>
72#include <NCollection_DataMap.hxx>
73#include <Graphic3d_Texture2Dmanual.hxx>
74#include <Prs3d_ShadingAspect.hxx>
7fd59977 75
25289ec1 76#ifdef WNT
77#undef DrawText
78#endif
79
80#include <Visual3d_Layer.hxx>
692613e5 81#include <cstdlib>
25289ec1 82
58655684 83#if defined(_WIN32)
4fe56619 84 #include <WNT_WClass.hxx>
85 #include <WNT_Window.hxx>
86
87 #if defined(_MSC_VER)
88 #define _CRT_SECURE_NO_DEPRECATE
89 #pragma warning (disable:4996)
90 #endif
91#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
4fe56619 92 #include <Cocoa_Window.hxx>
7fd59977 93#else
4fe56619 94 #include <Xw_Window.hxx>
95 #include <X11/Xlib.h> /* contains some dangerous #defines such as Status, True etc. */
96 #include <X11/Xutil.h>
97 #include <tk.h>
7fd59977 98#endif
99
8625ef7e 100inline Standard_Boolean parseOnOff (Standard_CString theArg,
101 Standard_Boolean& theIsOn)
102{
103 TCollection_AsciiString aFlag (theArg);
104 aFlag.LowerCase();
105 if (aFlag == "on"
106 || aFlag == "1")
107 {
108 theIsOn = Standard_True;
109 return Standard_True;
110 }
111 else if (aFlag == "off"
112 || aFlag == "0")
113 {
114 theIsOn = Standard_False;
115 return Standard_True;
116 }
117 return Standard_False;
118}
119
b514beda 120// Auxiliary definitions
121static const char THE_KEY_DELETE = 127;
7fd59977 122
123//==============================================================================
124// VIEWER GLOBAL VARIABLES
125//==============================================================================
126
127Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
b514beda 128Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
7fd59977 129
130Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
131extern const Handle(NIS_InteractiveContext)& TheNISContext();
4754e164 132extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
7fd59977 133
b514beda 134extern int VErase (Draw_Interpretor& theDI,
135 Standard_Integer theArgNb,
136 const char** theArgVec);
137
58655684 138#if defined(_WIN32)
7fd59977 139static Handle(WNT_Window)& VT_GetWindow() {
140 static Handle(WNT_Window) WNTWin;
141 return WNTWin;
142}
4fe56619 143#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
4fe56619 144static Handle(Cocoa_Window)& VT_GetWindow()
145{
146 static Handle(Cocoa_Window) aWindow;
147 return aWindow;
148}
149extern void ViewerTest_SetCocoaEventManagerView (const Handle(Cocoa_Window)& theWindow);
18d715bd 150extern void SetCocoaWindowTitle (const Handle(Cocoa_Window)& theWindow, Standard_CString theTitle);
151extern void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight);
152
7fd59977 153#else
7fd59977 154static Handle(Xw_Window)& VT_GetWindow(){
155 static Handle(Xw_Window) XWWin;
156 return XWWin;
157}
7fd59977 158
159static void VProcessEvents(ClientData,int);
160#endif
161
18d715bd 162static Handle(Aspect_DisplayConnection)& GetDisplayConnection()
163{
164 static Handle(Aspect_DisplayConnection) aDisplayConnection;
165 return aDisplayConnection;
166}
167
168static void SetDisplayConnection (const Handle(Aspect_DisplayConnection)& theDisplayConnection)
169{
170 GetDisplayConnection() = theDisplayConnection;
171}
172
58655684 173#if defined(_WIN32) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
18d715bd 174Aspect_Handle GetWindowHandle(const Handle(Aspect_Window)& theWindow)
dc3fe572 175{
0ebaa4db 176 Aspect_Handle aWindowHandle = (Aspect_Handle)NULL;
58655684 177#if defined(_WIN32)
18d715bd 178 const Handle (WNT_Window) aWindow = Handle(WNT_Window)::DownCast (theWindow);
179 if (!aWindow.IsNull())
180 return aWindow->HWindow();
181#elif (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
182 const Handle (Xw_Window) aWindow = Handle(Xw_Window)::DownCast (theWindow);
183 if (!aWindow.IsNull())
184 return aWindow->XWindow();
185#endif
186 return aWindowHandle;
dc3fe572 187}
18d715bd 188#endif
dc3fe572 189
de75ed09 190static Standard_Boolean MyHLRIsOn = Standard_False;
7fd59977 191
18d715bd 192NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
58655684 193static NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)> ViewerTest_myContexts;
18d715bd 194static NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)> ViewerTest_myDrivers;
58655684 195static OpenGl_Caps ViewerTest_myDefaultCaps;
18d715bd 196
7fd59977 197#define ZCLIPWIDTH 1.
198
199static void OSWindowSetup();
200
201//==============================================================================
202// EVENT GLOBAL VARIABLES
203//==============================================================================
204
205static int Start_Rot = 0;
206static int ZClipIsOn = 0;
4fe56619 207int X_Motion = 0; // Current cursor position
208int Y_Motion = 0;
209int X_ButtonPress = 0; // Last ButtonPress position
210int Y_ButtonPress = 0;
211Standard_Boolean IsDragged = Standard_False;
8abada55 212Standard_Boolean DragFirst = Standard_False;
7fd59977 213
214//==============================================================================
215
216#ifdef WNT
217static LRESULT WINAPI ViewerWindowProc(
218 HWND hwnd,
219 UINT uMsg,
220 WPARAM wParam,
221 LPARAM lParam );
222static LRESULT WINAPI AdvViewerWindowProc(
223 HWND hwnd,
224 UINT uMsg,
225 WPARAM wParam,
226 LPARAM lParam );
227#endif
228
229
230//==============================================================================
231//function : WClass
232//purpose :
233//==============================================================================
234
235const Handle(MMgt_TShared)& ViewerTest::WClass()
236{
237 static Handle(MMgt_TShared) theWClass;
58655684 238#if defined(_WIN32)
4fe56619 239 if (theWClass.IsNull())
240 {
7fd59977 241 theWClass = new WNT_WClass ("GW3D_Class", AdvViewerWindowProc,
242 CS_VREDRAW | CS_HREDRAW, 0, 0,
243 ::LoadCursor (NULL, IDC_ARROW));
244 }
245#endif
246 return theWClass;
247}
248
18d715bd 249//==============================================================================
250//function : CreateName
251//purpose : Create numerical name for new object in theMap
252//==============================================================================
253template <typename ObjectType>
254TCollection_AsciiString CreateName (const NCollection_DoubleMap <TCollection_AsciiString, ObjectType>& theObjectMap,
255 const TCollection_AsciiString& theDefaultString)
256{
257 if (theObjectMap.IsEmpty())
258 return theDefaultString + TCollection_AsciiString(1);
259
260 Standard_Integer aNextKey = 1;
261 Standard_Boolean isFound = Standard_False;
262 while (!isFound)
263 {
264 TCollection_AsciiString aStringKey = theDefaultString + TCollection_AsciiString(aNextKey);
265 // Look for objects with default names
266 if (theObjectMap.IsBound1(aStringKey))
267 {
268 aNextKey++;
269 }
270 else
271 isFound = Standard_True;
272 }
273
274 return theDefaultString + TCollection_AsciiString(aNextKey);
275}
276
277//==============================================================================
278//structure : ViewerTest_Names
279//purpose : Allow to operate with full view name: driverName/viewerName/viewName
280//==============================================================================
281struct ViewerTest_Names
282{
283private:
284 TCollection_AsciiString myDriverName;
285 TCollection_AsciiString myViewerName;
286 TCollection_AsciiString myViewName;
287
288public:
289
290 const TCollection_AsciiString& GetDriverName () const
291 {
292 return myDriverName;
293 }
294 void SetDriverName (const TCollection_AsciiString& theDriverName)
295 {
296 myDriverName = theDriverName;
297 }
298 const TCollection_AsciiString& GetViewerName () const
299 {
300 return myViewerName;
301 }
302 void SetViewerName (const TCollection_AsciiString& theViewerName)
303 {
304 myViewerName = theViewerName;
305 }
306 const TCollection_AsciiString& GetViewName () const
307 {
308 return myViewName;
309 }
310 void SetViewName (const TCollection_AsciiString& theViewName)
311 {
312 myViewName = theViewName;
313 }
314
315 //===========================================================================
316 //function : Constructor for ViewerTest_Names
317 //purpose : Get view, viewer, driver names from custom string
318 //===========================================================================
319
320 ViewerTest_Names (const TCollection_AsciiString& theInputString)
321 {
322 TCollection_AsciiString aName(theInputString);
323 if (theInputString.IsEmpty())
324 {
325 // Get current configuration
326 if (ViewerTest_myDrivers.IsEmpty())
327 myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
328 (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
329 else
330 myDriverName = ViewerTest_myDrivers.Find2
331 (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
332
333 if(ViewerTest_myContexts.IsEmpty())
334 {
335 myViewerName = CreateName <Handle(AIS_InteractiveContext)>
336 (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
337 }
338 else
339 myViewerName = ViewerTest_myContexts.Find2 (ViewerTest::GetAISContext());
340
341 myViewName = CreateName <Handle(V3d_View)>
342 (ViewerTest_myViews, TCollection_AsciiString(myViewerName + "/View"));
343 }
344 else
345 {
346 // There is at least view name
347 Standard_Integer aParserNumber = 0;
348 for (Standard_Integer i = 0; i < 3; ++i)
349 {
350 Standard_Integer aParserPos = aName.SearchFromEnd("/");
351 if(aParserPos != -1)
352 {
353 aParserNumber++;
354 aName.Split(aParserPos-1);
355 }
356 else
357 break;
358 }
359 if (aParserNumber == 0)
360 {
361 // Only view name
362 if (!ViewerTest::GetAISContext().IsNull())
363 {
364 myDriverName = ViewerTest_myDrivers.Find2
365 (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
366 myViewerName = ViewerTest_myContexts.Find2
367 (ViewerTest::GetAISContext());
368 }
369 else
370 {
371 // There is no opened contexts here, need to create names for viewer and driver
372 myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
373 (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
374
375 myViewerName = CreateName <Handle(AIS_InteractiveContext)>
376 (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
377 }
378 myViewName = TCollection_AsciiString(myViewerName + "/" + theInputString);
379 }
380 else if (aParserNumber == 1)
381 {
382 // Here is viewerName/viewName
383 if (!ViewerTest::GetAISContext().IsNull())
384 myDriverName = ViewerTest_myDrivers.Find2
385 (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
386 else
387 {
388 // There is no opened contexts here, need to create name for driver
389 myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
390 (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
391 }
392 myViewerName = TCollection_AsciiString(myDriverName + "/" + aName);
393
394 myViewName = TCollection_AsciiString(myDriverName + "/" + theInputString);
395 }
396 else
397 {
398 //Here is driverName/viewerName/viewName
399 myDriverName = TCollection_AsciiString(aName);
400
401 TCollection_AsciiString aViewerName(theInputString);
402 aViewerName.Split(aViewerName.SearchFromEnd("/") - 1);
403 myViewerName = TCollection_AsciiString(aViewerName);
404
405 myViewName = TCollection_AsciiString(theInputString);
406 }
407 }
408 }
409};
410
411//==============================================================================
412//function : FindContextByView
413//purpose : Find AIS_InteractiveContext by View
414//==============================================================================
415
416Handle(AIS_InteractiveContext) FindContextByView (const Handle(V3d_View)& theView)
417{
418 Handle(AIS_InteractiveContext) anAISContext;
419
420 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
421 anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
422 {
423 if (anIter.Value()->CurrentViewer() == theView->Viewer())
424 return anIter.Key2();
425 }
426 return anAISContext;
427}
428
429
430//==============================================================================
431//function : SetWindowTitle
432//purpose : Set window title
433//==============================================================================
434
435void SetWindowTitle (const Handle(Aspect_Window)& theWindow,
436 Standard_CString theTitle)
437{
58655684 438#if defined(_WIN32)
18d715bd 439 SetWindowText ((HWND)Handle(WNT_Window)::DownCast(theWindow)->HWindow(),
440 theTitle);
441#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
442 SetCocoaWindowTitle (Handle(Cocoa_Window)::DownCast(theWindow), theTitle);
443#else
444 if(GetDisplayConnection()->GetDisplay())
445 {
446 Window aWindow =
447 Handle(Xw_Window)::DownCast(theWindow)->XWindow();
448 XStoreName (GetDisplayConnection()->GetDisplay(), aWindow , theTitle);
449 }
450#endif
451}
452
453//==============================================================================
454//function : IsWindowOverlapped
455//purpose : Check if theWindow overlapp another view
456//==============================================================================
457
458Standard_Boolean IsWindowOverlapped (const Standard_Integer thePxLeft,
459 const Standard_Integer thePxTop,
460 const Standard_Integer thePxRight,
461 const Standard_Integer thePxBottom,
462 TCollection_AsciiString& theViewId)
463{
464 for(NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
465 anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
466 {
467 Standard_Integer aTop = 0,
468 aLeft = 0,
469 aRight = 0,
470 aBottom = 0;
471 anIter.Value()->Window()->Position(aLeft, aTop, aRight, aBottom);
472 if ((thePxLeft >= aLeft && thePxLeft <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
473 (thePxLeft >= aLeft && thePxLeft <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom) ||
474 (thePxRight >= aLeft && thePxRight <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
475 (thePxRight >= aLeft && thePxRight <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom))
476 {
477 theViewId = anIter.Key1();
478 return Standard_True;
479 }
480 }
481 return Standard_False;
482}
483
484// Workaround: to create and delete non-orthographic views outside ViewerTest
485void ViewerTest::RemoveViewName (const TCollection_AsciiString& theName)
486{
487 ViewerTest_myViews.UnBind1 (theName);
488}
489
490void ViewerTest::InitViewName (const TCollection_AsciiString& theName,
491 const Handle(V3d_View)& theView)
492{
493 ViewerTest_myViews.Bind (theName, theView);
494}
495
496TCollection_AsciiString ViewerTest::GetCurrentViewName ()
497{
498 return ViewerTest_myViews.Find2( ViewerTest::CurrentView());
499}
7fd59977 500//==============================================================================
501//function : ViewerInit
502//purpose : Create the window viewer and initialize all the global variable
503//==============================================================================
504
18d715bd 505TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft,
506 const Standard_Integer thePxTop,
507 const Standard_Integer thePxWidth,
508 const Standard_Integer thePxHeight,
509 Standard_CString theViewName,
510 Standard_CString theDisplayName)
7fd59977 511{
8c3c9904 512 // Default position and dimension of the viewer window.
4fe56619 513 // Note that left top corner is set to be sufficiently small to have
8c3c9904 514 // window fit in the small screens (actual for remote desktops, see #23003).
4fe56619 515 // The position corresponds to the window's client area, thus some
8c3c9904 516 // gap is added for window frame to be visible.
517 Standard_Integer aPxLeft = 20;
518 Standard_Integer aPxTop = 40;
7fd59977 519 Standard_Integer aPxWidth = 409;
520 Standard_Integer aPxHeight = 409;
18d715bd 521 Standard_Boolean toCreateViewer = Standard_False;
522
58655684 523 Handle(OpenGl_GraphicDriver) aGraphicDriver;
18d715bd 524 ViewerTest_Names aViewNames(theViewName);
525 if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName ()))
526 aViewNames.SetViewName (aViewNames.GetViewerName() + "/" + CreateName<Handle(V3d_View)>(ViewerTest_myViews, "View"));
527
528 if (thePxLeft != 0)
529 aPxLeft = thePxLeft;
530 if (thePxTop != 0)
531 aPxTop = thePxTop;
532 if (thePxWidth != 0)
533 aPxWidth = thePxWidth;
534 if (thePxHeight != 0)
7fd59977 535 aPxHeight = thePxHeight;
4269bd1b 536
18d715bd 537 // Get graphic driver (create it or get from another view)
538 if (!ViewerTest_myDrivers.IsBound1 (aViewNames.GetDriverName()))
539 {
540 // Get connection string
58655684 541 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
18d715bd 542 TCollection_AsciiString aDisplayName(theDisplayName);
498ce76b 543 if (!aDisplayName.IsEmpty())
18d715bd 544 SetDisplayConnection (new Aspect_DisplayConnection ());
545 else
546 SetDisplayConnection (new Aspect_DisplayConnection (aDisplayName));
18d715bd 547 #else
498ce76b 548 (void)theDisplayName; // avoid warning on unused argument
18d715bd 549 SetDisplayConnection (new Aspect_DisplayConnection ());
550 #endif
65993a95 551 aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
58655684 552 aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
18d715bd 553 ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
554 toCreateViewer = Standard_True;
555 }
556 else
557 {
58655684 558 aGraphicDriver = Handle(OpenGl_GraphicDriver)::DownCast (ViewerTest_myDrivers.Find1 (aViewNames.GetDriverName()));
7fd59977 559 }
560
18d715bd 561 //Dispose the window if input parameters are default
562 if (!ViewerTest_myViews.IsEmpty() && thePxLeft == 0 && thePxTop == 0)
7fd59977 563 {
18d715bd 564 Standard_Integer aTop = 0,
565 aLeft = 0,
566 aRight = 0,
567 aBottom = 0,
568 aScreenWidth = 0,
569 aScreenHeight = 0;
570
571 // Get screen resolution
572#if defined(_WIN32) || defined(__WIN32__)
573 RECT aWindowSize;
574 GetClientRect(GetDesktopWindow(), &aWindowSize);
575 aScreenHeight = aWindowSize.bottom;
576 aScreenWidth = aWindowSize.right;
577#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
578 GetCocoaScreenResolution (aScreenWidth, aScreenHeight);
579#else
580 Screen *aScreen = DefaultScreenOfDisplay(GetDisplayConnection()->GetDisplay());
581 aScreenWidth = WidthOfScreen(aScreen);
582 aScreenHeight = HeightOfScreen(aScreen);
583#endif
584
585 TCollection_AsciiString anOverlappedViewId("");
773f53f1 586
587 while (IsWindowOverlapped (aPxLeft, aPxTop, aPxLeft + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId))
dc3fe572 588 {
18d715bd 589 ViewerTest_myViews.Find1(anOverlappedViewId)->Window()->Position (aLeft, aTop, aRight, aBottom);
590
591 if (IsWindowOverlapped (aRight + 20, aPxTop, aRight + 20 + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId)
592 && aRight + 2*aPxWidth + 40 > aScreenWidth)
593 {
594 if (aBottom + aPxHeight + 40 > aScreenHeight)
595 {
596 aPxLeft = 20;
597 aPxTop = 40;
598 break;
599 }
600 aPxLeft = 20;
601 aPxTop = aBottom + 40;
602 }
603 else
604 aPxLeft = aRight + 20;
dc3fe572 605 }
18d715bd 606 }
607
608 // Get viewer name
609 TCollection_AsciiString aTitle("3D View - ");
610 aTitle = aTitle + aViewNames.GetViewName() + "(*)";
611
612 // Change name of current active window
613 if (!ViewerTest::CurrentView().IsNull())
614 {
615 TCollection_AsciiString aTitle("3D View - ");
616 aTitle = aTitle
617 + ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
618 SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
619 }
620
621 // Create viewer
eb4320f2 622 Handle(V3d_Viewer) a3DViewer;
18d715bd 623 // If it's the single view, we first look for empty context
624 if (ViewerTest_myViews.IsEmpty() && !ViewerTest_myContexts.IsEmpty())
625 {
626 NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
627 anIter(ViewerTest_myContexts);
628 if (anIter.More())
629 ViewerTest::SetAISContext (anIter.Value());
630 a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
18d715bd 631 }
632 else if (ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName()))
633 {
634 ViewerTest::SetAISContext(ViewerTest_myContexts.Find1(aViewNames.GetViewerName()));
635 a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
18d715bd 636 }
eb4320f2 637 else if (a3DViewer.IsNull())
18d715bd 638 {
639 toCreateViewer = Standard_True;
640 TCollection_ExtendedString NameOfWindow("Viewer3D");
641 a3DViewer = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
642
643 NameOfWindow = TCollection_ExtendedString("Collector");
18d715bd 644
645 a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
18d715bd 646 }
647
648 // AIS context setup
649 if (ViewerTest::GetAISContext().IsNull() ||
650 !(ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName())))
651 {
e79a94b9 652 Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (a3DViewer);
18d715bd 653 ViewerTest::SetAISContext (aContext);
654 ViewerTest_myContexts.Bind (aViewNames.GetViewerName(), ViewerTest::GetAISContext());
655 }
656 else
e79a94b9 657 {
18d715bd 658 ViewerTest::ResetEventManager();
e79a94b9 659 }
18d715bd 660
661 // Create window
e79a94b9 662#if defined(_WIN32)
663 VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
664 Handle(WNT_WClass)::DownCast (WClass()),
665 Draw_VirtualWindows ? WS_POPUPWINDOW : WS_OVERLAPPEDWINDOW,
666 aPxLeft, aPxTop,
667 aPxWidth, aPxHeight,
668 Quantity_NOC_BLACK);
4fe56619 669#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
e79a94b9 670 VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
671 aPxLeft, aPxTop,
672 aPxWidth, aPxHeight);
673 ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
7fd59977 674#else
e79a94b9 675 VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
676 aTitle.ToCString(),
677 aPxLeft, aPxTop,
678 aPxWidth, aPxHeight);
7fd59977 679#endif
18d715bd 680 VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
7fd59977 681
18d715bd 682 // NIS setup
683 Handle(NIS_View) aView = new NIS_View (a3DViewer, VT_GetWindow());
4269bd1b 684
18d715bd 685 ViewerTest::CurrentView(aView);
686 ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
687 TheNISContext()->AttachView (aView);
7fd59977 688
18d715bd 689 // Setup for X11 or NT
690 OSWindowSetup();
7fd59977 691
18d715bd 692 // Set parameters for V3d_View and V3d_Viewer
693 const Handle (V3d_View) aV3dView = ViewerTest::CurrentView();
694 aV3dView->SetComputedMode(Standard_False);
695 MyHLRIsOn = aV3dView->ComputedMode();
696 aV3dView->SetZClippingDepth(0.5);
697 aV3dView->SetZClippingWidth(ZCLIPWIDTH/2.);
7fd59977 698
18d715bd 699 a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
700 if (toCreateViewer)
701 {
7fd59977 702 a3DViewer->SetDefaultLights();
703 a3DViewer->SetLightOn();
18d715bd 704 }
7fd59977 705
e79a94b9 706 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
4fe56619 707 #if TCL_MAJOR_VERSION < 8
18d715bd 708 Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
7fd59977 709 TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
4fe56619 710 #else
18d715bd 711 Tk_CreateFileHandler(XConnectionNumber(GetDisplayConnection()->GetDisplay()),
7fd59977 712 TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
4fe56619 713 #endif
714 #endif
7fd59977 715
7fd59977 716 VT_GetWindow()->Map();
4269bd1b 717
18d715bd 718 // Set the handle of created view in the event manager
719 ViewerTest::ResetEventManager();
720
4fe56619 721 ViewerTest::CurrentView()->Redraw();
18d715bd 722
723 aView.Nullify();
724 a3DViewer.Nullify();
18d715bd 725
726 return aViewNames.GetViewName();
727}
728
4269bd1b 729//==============================================================================
730//function : RedrawAllViews
731//purpose : Redraw all created views
732//==============================================================================
733void ViewerTest::RedrawAllViews()
734{
735 NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
736 for (; aViewIt.More(); aViewIt.Next())
737 {
738 const Handle(V3d_View)& aView = aViewIt.Key2();
739 aView->Redraw();
740 }
741}
742
7fd59977 743//==============================================================================
744//function : Vinit
745//purpose : Create the window viewer and initialize all the global variable
e79a94b9 746// Use Tk_CreateFileHandler on UNIX to catch the X11 Viewer event
7fd59977 747//==============================================================================
748
18d715bd 749static int VInit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
7fd59977 750{
e79a94b9 751 if (theArgsNb > 9)
18d715bd 752 {
e79a94b9 753 std::cerr << theArgVec[0] << ": incorrect number of command arguments.\n"
754 << "Type help for more information.\n";
18d715bd 755 return 1;
756 }
18d715bd 757
e79a94b9 758 TCollection_AsciiString aViewName, aDisplayName;
759 Standard_Integer aPxLeft = 0, aPxTop = 0, aPxWidth = 0, aPxHeight = 0;
760 TCollection_AsciiString aName, aValue;
761 for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
18d715bd 762 {
e79a94b9 763 const TCollection_AsciiString anArg = theArgVec[anArgIt];
764 TCollection_AsciiString anArgCase = anArg;
765 anArgCase.UpperCase();
1d7ca641 766 if (ViewerTest::SplitParameter (anArg, aName, aValue))
18d715bd 767 {
e79a94b9 768 aName.UpperCase();
769 if (aName.IsEqual ("NAME"))
18d715bd 770 {
771 aViewName = aValue;
772 }
e79a94b9 773 else if (aName.IsEqual ("L")
774 || aName.IsEqual ("LEFT"))
775 {
18d715bd 776 aPxLeft = aValue.IntegerValue();
e79a94b9 777 }
778 else if (aName.IsEqual ("T")
779 || aName.IsEqual ("TOP"))
780 {
18d715bd 781 aPxTop = aValue.IntegerValue();
e79a94b9 782 }
783 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
784 else if (aName.IsEqual ("DISP")
785 || aName.IsEqual ("DISPLAY"))
786 {
18d715bd 787 aDisplayName = aValue;
e79a94b9 788 }
789 #endif
790 else if (aName.IsEqual ("W")
791 || aName.IsEqual ("WIDTH"))
792 {
18d715bd 793 aPxWidth = aValue.IntegerValue();
e79a94b9 794 }
795 else if (aName.IsEqual ("H")
796 || aName.IsEqual ("HEIGHT"))
797 {
18d715bd 798 aPxHeight = aValue.IntegerValue();
e79a94b9 799 }
18d715bd 800 else
801 {
e79a94b9 802 std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
18d715bd 803 }
804 }
e79a94b9 805 else if (aViewName.IsEmpty())
806 {
807 aViewName = anArg;
808 }
809 else
810 {
811 std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
812 }
18d715bd 813 }
814
815 ViewerTest_Names aViewNames (aViewName);
e79a94b9 816 if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
18d715bd 817 {
e79a94b9 818 TCollection_AsciiString aCommand = TCollection_AsciiString ("vactivate ") + aViewNames.GetViewName();
819 theDi.Eval (aCommand.ToCString());
18d715bd 820 return 0;
821 }
822
823 TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight,
824 aViewName.ToCString(),
825 aDisplayName.ToCString());
e79a94b9 826 theDi << aViewId;
7fd59977 827 return 0;
828}
829
0a768f56 830//==============================================================================
831//function : VHLR
832//purpose : hidden lines removal algorithm
e9224045 833//draw args: vhlr is_enabled={on|off} [show_hidden={1|0}]
0a768f56 834//==============================================================================
835
836static int VHLR (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
837{
838 if (ViewerTest::CurrentView().IsNull())
839 {
840 di << argv[0] << ": Call vinit before this command, please.\n";
841 return 1;
842 }
843
e9224045 844 if (argc < 2)
0a768f56 845 {
846 di << argv[0] << ": Wrong number of command arguments.\n"
847 << "Type help " << argv[0] << " for more information.\n";
848 return 1;
849 }
850
e9224045 851 // Enable or disable HLR mode.
0a768f56 852 Standard_Boolean isHLROn =
853 (!strcasecmp (argv[1], "on")) ? Standard_True : Standard_False;
854
e9224045 855 if (isHLROn != MyHLRIsOn)
0a768f56 856 {
e9224045 857 MyHLRIsOn = isHLROn;
858 ViewerTest::CurrentView()->SetComputedMode (MyHLRIsOn);
0a768f56 859 }
860
e9224045 861 // Show or hide hidden lines in HLR mode.
862 Standard_Boolean isCurrentShowHidden
863 = ViewerTest::GetAISContext()->DefaultDrawer()->DrawHiddenLine();
864
865 Standard_Boolean isShowHidden =
866 (argc == 3) ? (atoi(argv[2]) == 1 ? Standard_True : Standard_False)
867 : isCurrentShowHidden;
868
869
870 if (isShowHidden != isCurrentShowHidden)
871 {
872 if (isShowHidden)
873 {
874 ViewerTest::GetAISContext()->DefaultDrawer()->EnableDrawHiddenLine();
875 }
876 else
877 {
878 ViewerTest::GetAISContext()->DefaultDrawer()->DisableDrawHiddenLine();
879 }
880
881 // Redisplay shapes.
882 if (MyHLRIsOn)
883 {
884 AIS_ListOfInteractive aListOfShapes;
885 ViewerTest::GetAISContext()->DisplayedObjects (aListOfShapes);
886
887 for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes); anIter.More(); anIter.Next())
888 {
889 Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (anIter.Value());
890 if (aShape.IsNull())
891 {
892 continue;
893 }
894 aShape->Redisplay();
895 }
896 }
897 }
0a768f56 898
e9224045 899 ViewerTest::CurrentView()->Update();
0a768f56 900 return 0;
901}
902
903//==============================================================================
904//function : VHLRType
905//purpose : change type of using HLR algorithm
906//==============================================================================
907
908static int VHLRType (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
909{
910 if (ViewerTest::CurrentView().IsNull())
911 {
912 di << argv[0] << ": Call vinit before this command, please.\n";
913 return 1;
914 }
915
916 if (argc < 2)
917 {
918 di << argv[0] << ": Wrong number of command arguments.\n"
919 << "Type help " << argv[0] << " for more information.\n";
920 return 1;
921 }
922
923 Prs3d_TypeOfHLR aTypeOfHLR =
924 (!strcasecmp (argv[1], "algo")) ? Prs3d_TOH_Algo : Prs3d_TOH_PolyAlgo;
925
926 if (argc == 2)
927 {
928 AIS_ListOfInteractive aListOfShapes;
929 ViewerTest::GetAISContext()->DisplayedObjects (aListOfShapes);
930 ViewerTest::GetAISContext()->DefaultDrawer()->SetTypeOfHLR(aTypeOfHLR);
931 for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes);
932 anIter.More(); anIter.Next())
933 {
934 Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
935 if (aShape.IsNull())
936 continue;
937 if (aShape->TypeOfHLR() != aTypeOfHLR)
938 aShape->SetTypeOfHLR (aTypeOfHLR);
939 if (MyHLRIsOn)
940 aShape->Redisplay();
941 }
942 ViewerTest::CurrentView()->Update();
943 return 0;
944 }
945 else
946 {
947 for (Standard_Integer i = 2; i < argc; ++i)
948 {
949 ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
950 TCollection_AsciiString aName (argv[i]);
951
952 if (!aMap.IsBound2 (aName))
953 {
954 di << argv[0] << ":" << " Wrong shape name:" << aName.ToCString() << ".\n";
955 continue;
956 }
957 Handle(AIS_Shape) anAISObject =
958 Handle(AIS_Shape)::DownCast (aMap.Find2(aName));
959 if (anAISObject.IsNull())
960 continue;
961 anAISObject->SetTypeOfHLR (aTypeOfHLR);
962 if (MyHLRIsOn)
963 anAISObject->Redisplay();
964 }
965 ViewerTest::CurrentView()->Update();
966 }
967
968 return 0;
969}
970
18d715bd 971//==============================================================================
972//function : FindViewIdByWindowHandle
973//purpose : Find theView Id in the map of views by window handle
974//==============================================================================
975#if defined(_WIN32) || defined(__WIN32__) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
976TCollection_AsciiString FindViewIdByWindowHandle(const Aspect_Handle theWindowHandle)
977{
978 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator
979 anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
980 {
981 Aspect_Handle aWindowHandle = GetWindowHandle(anIter.Value()->Window());
982 if (aWindowHandle == theWindowHandle)
983 return anIter.Key1();
984 }
985 return TCollection_AsciiString("");
986}
987#endif
988
989//==============================================================================
990//function : ActivateView
991//purpose : Make the view active
992//==============================================================================
993
994void ActivateView (const TCollection_AsciiString& theViewName)
995{
996 const Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
997 if (!aView.IsNull())
998 {
999 Handle(AIS_InteractiveContext) anAISContext = FindContextByView(aView);
1000 if (!anAISContext.IsNull())
1001 {
1002 if (!ViewerTest::CurrentView().IsNull())
1003 {
1004 TCollection_AsciiString aTitle("3D View - ");
1005 aTitle = aTitle + ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
1006 SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1007 }
1008
1009 ViewerTest::CurrentView (aView);
1010 // Update degenerate mode
1011 MyHLRIsOn = ViewerTest::CurrentView()->ComputedMode();
1012 ViewerTest::SetAISContext (anAISContext);
1013 TCollection_AsciiString aTitle = TCollection_AsciiString("3D View - ");
1014 aTitle = aTitle + theViewName + "(*)";
1015 SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1016#if defined(_WIN32) || defined(__WIN32__)
1017 VT_GetWindow() = Handle(WNT_Window)::DownCast(ViewerTest::CurrentView()->Window());
1018#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1019 VT_GetWindow() = Handle(Cocoa_Window)::DownCast(ViewerTest::CurrentView()->Window());
1020#else
1021 VT_GetWindow() = Handle(Xw_Window)::DownCast(ViewerTest::CurrentView()->Window());
1022#endif
1023 SetDisplayConnection(ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
1024 ViewerTest::CurrentView()->Redraw();
1025 }
1026 }
1027}
1028
0e93d9e5 1029//==============================================================================
1030//function : RemoveView
1031//purpose :
1032//==============================================================================
1033void ViewerTest::RemoveView (const Handle(V3d_View)& theView,
1034 const Standard_Boolean theToRemoveContext)
1035{
1036 if (!ViewerTest_myViews.IsBound2 (theView))
1037 {
1038 return;
1039 }
1040
1041 const TCollection_AsciiString aViewName = ViewerTest_myViews.Find2 (theView);
1042 RemoveView (aViewName, theToRemoveContext);
1043}
1044
18d715bd 1045//==============================================================================
1046//function : RemoveView
1047//purpose : Close and remove view from display, clear maps if neccessary
1048//==============================================================================
1049void ViewerTest::RemoveView (const TCollection_AsciiString& theViewName, const Standard_Boolean isContextRemoved)
1050{
1051 if (!ViewerTest_myViews.IsBound1(theViewName))
1052 {
1053 cout << "Wrong view name\n";
1054 return;
1055 }
1056
1057 // Activate another view if it's active now
1058 if (ViewerTest_myViews.Find1(theViewName) == ViewerTest::CurrentView())
1059 {
1060 if (ViewerTest_myViews.Extent() > 1)
1061 {
1062 TCollection_AsciiString aNewViewName;
1063 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> :: Iterator
1064 anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
1065 if (anIter.Key1() != theViewName)
1066 {
1067 aNewViewName = anIter.Key1();
1068 break;
1069 }
1070 ActivateView (aNewViewName);
1071 }
1072 else
1073 {
1074 Handle(V3d_View) anEmptyView;
1075#if defined(_WIN32) || defined(__WIN32__)
1076 Handle(WNT_Window) anEmptyWindow;
1077#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1078 Handle(Cocoa_Window) anEmptyWindow;
1079#else
1080 Handle(Xw_Window) anEmptyWindow;
1081#endif
1082 VT_GetWindow() = anEmptyWindow;
1083 ViewerTest::CurrentView (anEmptyView);
1084 if (isContextRemoved)
1085 {
1086 Handle(AIS_InteractiveContext) anEmptyContext;
1087 ViewerTest::SetAISContext(anEmptyContext);
1088 }
1089 }
1090 }
1091
1092 // Delete view
1093 Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
1094 Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
1095
1096 // Remove view resources
1097 TheNISContext()->DetachView(Handle(NIS_View)::DownCast(aView));
1098 ViewerTest_myViews.UnBind1(theViewName);
1099 aView->Remove();
1100
1101#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1102 XFlush (GetDisplayConnection()->GetDisplay());
1103#endif
1104
1105 // Keep context opened only if the closed view is last to avoid
1106 // unused empty contexts
1107 if (!aCurrentContext.IsNull())
1108 {
1109 // Check if there are more difined views in the viewer
1110 aCurrentContext->CurrentViewer()->InitDefinedViews();
1111 if ((isContextRemoved || ViewerTest_myContexts.Size() != 1) && !aCurrentContext->CurrentViewer()->MoreDefinedViews())
1112 {
1113 // Remove driver if there is no viewers that use it
1114 Standard_Boolean isRemoveDriver = Standard_True;
1115 for(NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1116 anIter(ViewerTest_myContexts); anIter.More(); anIter.Next())
1117 {
1118 if (aCurrentContext != anIter.Key2() &&
1119 aCurrentContext->CurrentViewer()->Driver() == anIter.Value()->CurrentViewer()->Driver())
1120 {
1121 isRemoveDriver = Standard_False;
1122 break;
1123 }
1124 }
1125 if(isRemoveDriver)
1126 {
1127 ViewerTest_myDrivers.UnBind2 (aCurrentContext->CurrentViewer()->Driver());
1128 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1129 #if TCL_MAJOR_VERSION < 8
1130 Tk_DeleteFileHandler((void*)XConnectionNumber(aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
1131 #else
1132 Tk_DeleteFileHandler(XConnectionNumber(aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
1133 #endif
1134 #endif
1135 }
1136
1137 ViewerTest_myContexts.UnBind2(aCurrentContext);
1138 }
1139 }
1140 cout << "3D View - " << theViewName << " was deleted.\n";
1141
1142}
1143
1144//==============================================================================
1145//function : VClose
1146//purpose : Remove the view defined by its name
1147//==============================================================================
1148
d0cc1cb7 1149static int VClose (Draw_Interpretor& /*theDi*/,
1150 Standard_Integer theArgsNb,
1151 const char** theArgVec)
18d715bd 1152{
18d715bd 1153 NCollection_List<TCollection_AsciiString> aViewList;
d0cc1cb7 1154 if (theArgsNb > 1)
18d715bd 1155 {
d0cc1cb7 1156 TCollection_AsciiString anArg (theArgVec[1]);
1157 anArg.UpperCase();
1158 if (anArg.IsEqual ("ALL")
1159 || anArg.IsEqual ("*"))
1160 {
1161 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
1162 anIter.More(); anIter.Next())
1163 {
1164 aViewList.Append (anIter.Key1());
1165 }
1166 if (aViewList.IsEmpty())
1167 {
1168 std::cout << "No view to close\n";
1169 return 0;
1170 }
1171 }
1172 else
18d715bd 1173 {
d0cc1cb7 1174 ViewerTest_Names aViewName (theArgVec[1]);
1175 if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
1176 {
1177 std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
1178 return 1;
1179 }
1180 aViewList.Append (aViewName.GetViewName());
18d715bd 1181 }
1182 }
1183 else
1184 {
d0cc1cb7 1185 // close active view
1186 if (ViewerTest::CurrentView().IsNull())
1187 {
1188 std::cerr << "No active view!\n";
1189 return 1;
1190 }
1191 aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
18d715bd 1192 }
1193
d0cc1cb7 1194 Standard_Boolean toRemoveContext = (theArgsNb != 3 || Draw::Atoi (theArgVec[2]) != 1);
18d715bd 1195 for (NCollection_List<TCollection_AsciiString>::Iterator anIter(aViewList);
1196 anIter.More(); anIter.Next())
1197 {
d0cc1cb7 1198 ViewerTest::RemoveView (anIter.Value(), toRemoveContext);
18d715bd 1199 }
1200
1201 return 0;
1202}
1203
1204//==============================================================================
1205//function : VActivate
1206//purpose : Activate the view defined by its ID
1207//==============================================================================
1208
1209static int VActivate (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
1210{
1211 if (theArgsNb > 2)
1212 {
1213 theDi << theArgVec[0] << ": wrong number of command arguments.\n"
1214 << "Usage: " << theArgVec[0] << " ViewID\n";
1215 return 1;
1216 }
1217 if(theArgsNb == 1)
1218 {
1219 theDi.Eval("vviewlist");
1220 return 0;
1221 }
1222
1223 TCollection_AsciiString aNameString(theArgVec[1]);
29cb310a 1224 if ( strcasecmp( aNameString.ToCString(), "NONE" ) == 0 )
18d715bd 1225 {
1226 TCollection_AsciiString aTitle("3D View - ");
1227 aTitle = aTitle + ViewerTest_myViews.Find2(ViewerTest::CurrentView());
1228 SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1229 Handle(V3d_View) anEmptyView;
1230#if defined(_WIN32) || defined(__WIN32__)
1231 Handle(WNT_Window) anEmptyWindow;
1232#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1233 Handle(Cocoa_Window) anEmptyWindow;
1234#else
1235 Handle(Xw_Window) anEmptyWindow;
1236#endif
1237 VT_GetWindow() = anEmptyWindow;
1238 ViewerTest::CurrentView (anEmptyView);
1239 ViewerTest::ResetEventManager();
1240 theDi << theArgVec[0] << ": all views are inactive\n";
1241 return 0;
1242 }
1243
1244 ViewerTest_Names aViewNames(aNameString);
1245
1246 // Check if this view exists in the viewer with the driver
1247 if (!ViewerTest_myViews.IsBound1(aViewNames.GetViewName()))
1248 {
1249 theDi << "Wrong view name\n";
1250 return 1;
1251 }
1252
1253 // Check if it is active already
1254 if (ViewerTest::CurrentView() == ViewerTest_myViews.Find1(aViewNames.GetViewName()))
1255 {
1256 theDi << theArgVec[0] << ": the view is active already\n";
1257 return 0;
1258 }
1259
1260 ActivateView (aViewNames.GetViewName());
1261 return 0;
1262}
1263
1264//==============================================================================
1265//function : VViewList
1266//purpose : Print current list of views per viewer and graphic driver ID
1267// shared between viewers
1268//==============================================================================
1269
1270static int VViewList (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
1271{
1272 if (theArgsNb > 2)
1273 {
1274 theDi << theArgVec[0] << ": Wrong number of command arguments\n"
29cb310a 1275 << "Usage: " << theArgVec[0] << " name";
18d715bd 1276 return 1;
1277 }
1278 if (ViewerTest_myContexts.Size() < 1)
1279 return 0;
1280
18d715bd 1281 Standard_Boolean isTreeView =
29cb310a 1282 (( theArgsNb==1 ) || ( strcasecmp( theArgVec[1], "long" ) != 0 ));
18d715bd 1283
1284 if (isTreeView)
1285 theDi << theArgVec[0] <<":\n";
1286
1287 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
1288 aDriverIter(ViewerTest_myDrivers); aDriverIter.More(); aDriverIter.Next())
1289 {
1290 if (isTreeView)
1291 theDi << aDriverIter.Key1() << ":\n";
1292
1293 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1294 aContextIter(ViewerTest_myContexts); aContextIter.More(); aContextIter.Next())
1295 {
1296 if (aContextIter.Key1().Search(aDriverIter.Key1()) != -1)
1297 {
1298 if (isTreeView)
1299 {
1300 TCollection_AsciiString aContextName(aContextIter.Key1());
1301 theDi << " " << aContextName.Split(aDriverIter.Key1().Length() + 1) << ":" << "\n";
1302 }
1303
1304 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
1305 aViewIter(ViewerTest_myViews); aViewIter.More(); aViewIter.Next())
1306 {
1307 if (aViewIter.Key1().Search(aContextIter.Key1()) != -1)
1308 {
1309 TCollection_AsciiString aViewName(aViewIter.Key1());
1310 if (isTreeView)
1311 {
1312 if (aViewIter.Value() == ViewerTest::CurrentView())
1313 theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "(*)" << "\n";
1314 else
1315 theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "\n";
1316 }
1317 else
1318 {
1319 theDi << aViewName << " ";
1320 }
1321 }
1322 }
1323 }
1324 }
1325 }
1326 return 0;
1327}
1328
7fd59977 1329//==============================================================================
4fe56619 1330//function : VT_ProcessKeyPress
7fd59977 1331//purpose : Handle KeyPress event from a CString
1332//==============================================================================
4fe56619 1333void VT_ProcessKeyPress (const char* buf_ret)
7fd59977 1334{
1335 //cout << "KeyPress" << endl;
1336 const Handle(V3d_View) aView = ViewerTest::CurrentView();
1337 const Handle(NIS_View) aNisView = Handle(NIS_View)::DownCast (aView);
1338 // Letter in alphabetic order
1339
b514beda 1340 if (!strcasecmp (buf_ret, "A"))
1341 {
7fd59977 1342 // AXO
1343 aView->SetProj(V3d_XposYnegZpos);
1344 }
b514beda 1345 else if (!strcasecmp (buf_ret, "D"))
1346 {
7fd59977 1347 // Reset
1348 aView->Reset();
1349 }
b514beda 1350 else if (!strcasecmp (buf_ret, "F"))
1351 {
7fd59977 1352 // FitAll
1353 if (aNisView.IsNull())
1354 aView->FitAll();
1355 else
1356 aNisView->FitAll3d();
1357 }
b514beda 1358 else if (!strcasecmp (buf_ret, "H"))
1359 {
7fd59977 1360 // HLR
1361 cout << "HLR" << endl;
de75ed09 1362 aView->SetComputedMode (!aView->ComputedMode());
1363 MyHLRIsOn = aView->ComputedMode();
7fd59977 1364 }
b514beda 1365 else if (!strcasecmp (buf_ret, "P"))
1366 {
0a768f56 1367 // Type of HLR
1368 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
1369 if (aContext->DefaultDrawer()->TypeOfHLR() == Prs3d_TOH_Algo)
1370 aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_PolyAlgo);
1371 else
1372 aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_Algo);
1373 if (aContext->NbCurrents()==0 || aContext->NbSelected() == 0)
1374 {
1375 AIS_ListOfInteractive aListOfShapes;
1376 aContext->DisplayedObjects(aListOfShapes);
1377 for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes);
1378 anIter.More(); anIter.Next())
1379 {
1380 Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
1381 if (aShape.IsNull())
1382 continue;
1383 if (aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
1384 aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
1385 else
1386 aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
1387 aShape->Redisplay();
1388 }
1389 }
1390 else
1391 {
1392 for (aContext->InitCurrent();aContext->MoreCurrent();aContext->NextCurrent())
1393 {
1394 Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(aContext->Current());
1395 if (aShape.IsNull())
1396 continue;
1397 if(aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
1398 aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
1399 else
1400 aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
1401 aShape->Redisplay();
1402 }
1403 }
1404
1405 aContext->UpdateCurrentViewer();
4269bd1b 1406
0a768f56 1407 }
b514beda 1408 else if (!strcasecmp (buf_ret, "S"))
1409 {
1410 std::cout << "setup Shaded display mode" << std::endl;
4fe56619 1411
7fd59977 1412 Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1413 if(Ctx->NbCurrents()==0 ||
1414 Ctx->NbSelected()==0)
1415 Ctx->SetDisplayMode(AIS_Shaded);
1416 else{
1417 if(Ctx->HasOpenedContext()){
1418 for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1419 Ctx->SetDisplayMode(Ctx->Interactive(),1,Standard_False);
1420 }
1421 else{
1422 for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
1423 Ctx->SetDisplayMode(Ctx->Current(),1,Standard_False);
1424 }
1425 Ctx->UpdateCurrentViewer();
1426 }
1427 }
b514beda 1428 else if (!strcasecmp (buf_ret, "U"))
1429 {
41811896 1430 // Unset display mode
b514beda 1431 std::cout << "reset display mode to defaults" << std::endl;
4fe56619 1432
7fd59977 1433 Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1434 if(Ctx->NbCurrents()==0 ||
1435 Ctx->NbSelected()==0)
1436 Ctx->SetDisplayMode(AIS_WireFrame);
1437 else{
1438 if(Ctx->HasOpenedContext()){
1439 for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1440 Ctx->UnsetDisplayMode(Ctx->Interactive(),Standard_False);
1441 }
1442 else{
1443 for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
1444 Ctx->UnsetDisplayMode(Ctx->Current(),Standard_False);
1445 }
1446 Ctx->UpdateCurrentViewer();
1447 }
1448
1449 }
b514beda 1450 else if (!strcasecmp (buf_ret, "T"))
1451 {
7fd59977 1452 // Top
1453 aView->SetProj(V3d_Zpos);
1454 }
b514beda 1455 else if (!strcasecmp (buf_ret, "B"))
1456 {
41811896 1457 // Bottom
7fd59977 1458 aView->SetProj(V3d_Zneg);
1459 }
b514beda 1460 else if (!strcasecmp (buf_ret, "L"))
1461 {
41811896 1462 // Left
7fd59977 1463 aView->SetProj(V3d_Xneg);
1464 }
b514beda 1465 else if (!strcasecmp (buf_ret, "R"))
1466 {
41811896 1467 // Right
7fd59977 1468 aView->SetProj(V3d_Xpos);
1469 }
b514beda 1470 else if (!strcasecmp (buf_ret, "W"))
1471 {
1472 std::cout << "setup WireFrame display mode" << std::endl;
7fd59977 1473 Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1474 if(Ctx->NbCurrents()==0 ||
1475 Ctx->NbSelected()==0)
1476 Ctx->SetDisplayMode(AIS_WireFrame);
1477 else{
1478 if(Ctx->HasOpenedContext()){
1479 for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1480 Ctx->SetDisplayMode(Ctx->Interactive(),0,Standard_False);
1481 }
1482 else{
1483 for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
1484 Ctx->SetDisplayMode(Ctx->Current(),0,Standard_False);
1485 }
1486 Ctx->UpdateCurrentViewer();
1487 }
1488 }
b514beda 1489 else if (!strcasecmp (buf_ret, "Z"))
1490 {
7fd59977 1491 // ZCLIP
7fd59977 1492 if ( ZClipIsOn ) {
1493 cout << "ZClipping OFF" << endl;
1494 ZClipIsOn = 0;
1495
1496 aView->SetZClippingType(V3d_OFF);
1497 aView->Redraw();
1498 }
1499 else {
1500 cout << "ZClipping ON" << endl;
1501 ZClipIsOn = 1;
1502
1503 aView->SetZClippingType(V3d_FRONT);
1504 aView->Redraw();
1505 }
1506 }
b514beda 1507 else if (!strcasecmp (buf_ret, ","))
1508 {
7fd59977 1509 ViewerTest::GetAISContext()->HilightNextDetected(ViewerTest::CurrentView());
7fd59977 1510 }
b514beda 1511 else if (!strcasecmp (buf_ret, "."))
1512 {
7fd59977 1513 ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
1514 }
b514beda 1515 else if (*buf_ret == THE_KEY_DELETE)
1516 {
1517 Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1518 if (!aCtx.IsNull()
1519 && aCtx->NbCurrents() > 0
1520 && aCtx->NbSelected() > 0)
1521 {
1522 Draw_Interprete ("verase");
1523 }
1524 }
1525 else
1526 {
1527 // Number
91322f44 1528 Standard_Integer Num = Draw::Atoi(buf_ret);
7fd59977 1529 if(Num>=0 && Num<=7)
1530 ViewerTest::StandardModeActivation(Num);
1531 }
1532}
1533
1534//==============================================================================
4fe56619 1535//function : VT_ProcessExpose
7fd59977 1536//purpose : Redraw the View on an Expose Event
1537//==============================================================================
4fe56619 1538void VT_ProcessExpose()
1539{
1540 Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1541 if (!aView3d.IsNull())
1542 {
1543 aView3d->Redraw();
1544 }
7fd59977 1545}
1546
1547//==============================================================================
4fe56619 1548//function : VT_ProcessConfigure
7fd59977 1549//purpose : Resize the View on an Configure Event
1550//==============================================================================
4fe56619 1551void VT_ProcessConfigure()
7fd59977 1552{
4fe56619 1553 Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1554 if (aView3d.IsNull())
1555 {
1556 return;
1557 }
1558
1559 aView3d->MustBeResized();
1560 aView3d->Update();
1561 aView3d->Redraw();
7fd59977 1562}
1563
1564//==============================================================================
4fe56619 1565//function : VT_ProcessButton1Press
7fd59977 1566//purpose : Picking
1567//==============================================================================
e79a94b9 1568Standard_Boolean VT_ProcessButton1Press (Standard_Integer ,
1569 const char** theArgVec,
1570 Standard_Boolean theToPick,
1571 Standard_Boolean theIsShift)
7fd59977 1572{
e79a94b9 1573 if (theToPick)
1574 {
7fd59977 1575 Standard_Real X, Y, Z;
e79a94b9 1576 ViewerTest::CurrentView()->Convert (X_Motion, Y_Motion, X, Y, Z);
7fd59977 1577
e79a94b9 1578 Draw::Set (theArgVec[1], X);
1579 Draw::Set (theArgVec[2], Y);
1580 Draw::Set (theArgVec[3], Z);
1581 }
7fd59977 1582
e79a94b9 1583 if (theIsShift)
1584 {
1585 ViewerTest::CurrentEventManager()->ShiftSelect();
1586 }
7fd59977 1587 else
e79a94b9 1588 {
1589 ViewerTest::CurrentEventManager()->Select();
1590 }
7fd59977 1591
e79a94b9 1592 return Standard_False;
7fd59977 1593}
1594
1595//==============================================================================
4fe56619 1596//function : VT_ProcessButton1Release
1597//purpose : End selecting
7fd59977 1598//==============================================================================
4fe56619 1599void VT_ProcessButton1Release (Standard_Boolean theIsShift)
1600{
1601 if (IsDragged)
1602 {
1603 IsDragged = Standard_False;
1604 Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
1605 if (theIsShift)
1606 {
1607 EM->ShiftSelect (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
1608 Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
1609 }
1610 else
1611 {
1612 EM->Select (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
1613 Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
1614 }
1615 }
1616}
7fd59977 1617
4fe56619 1618//==============================================================================
1619//function : VT_ProcessButton3Press
1620//purpose : Start Rotation
1621//==============================================================================
1622void VT_ProcessButton3Press()
1623{
7fd59977 1624 Start_Rot = 1;
de75ed09 1625 if (MyHLRIsOn)
1626 {
1627 ViewerTest::CurrentView()->SetComputedMode (Standard_False);
1628 }
7fd59977 1629 ViewerTest::CurrentView()->StartRotation( X_ButtonPress, Y_ButtonPress );
7fd59977 1630}
4fe56619 1631
7fd59977 1632//==============================================================================
4fe56619 1633//function : VT_ProcessButton3Release
1634//purpose : End rotation
7fd59977 1635//==============================================================================
4fe56619 1636void VT_ProcessButton3Release()
1637{
1638 if (Start_Rot)
1639 {
7fd59977 1640 Start_Rot = 0;
de75ed09 1641 if (MyHLRIsOn)
1642 {
1643 ViewerTest::CurrentView()->SetComputedMode (Standard_True);
1644 }
7fd59977 1645 }
7fd59977 1646}
1647
1648//==============================================================================
1649//function : ProcessZClipMotion
1650//purpose : Zoom
1651//==============================================================================
1652
1653void ProcessZClipMotion()
1654{
1655 Handle(V3d_View) a3DView = ViewerTest::CurrentView();
1656 if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
1657 static Standard_Real CurZPos = 0.;
1658
1659 //Quantity_Length VDX, VDY;
1660 //a3DView->Size(VDX,VDY);
1661 //Standard_Real VDZ = a3DView->ZSize();
1662 //printf("View size (%lf,%lf,%lf)\n", VDX, VDY, VDZ);
1663
1664 Quantity_Length dx = a3DView->Convert(X_Motion - X_ButtonPress);
1665
1666 // Front = Depth + width/2.
1667 Standard_Real D = 0.5;
1668 Standard_Real W = 0.1;
1669
1670 CurZPos += (dx);
1671
1672 D += CurZPos;
1673
1674 //printf("dx %lf Depth %lf Width %lf\n", dx, D, W);
1675
1676 a3DView->SetZClippingType(V3d_OFF);
1677 a3DView->SetZClippingDepth(D);
1678 a3DView->SetZClippingWidth(W);
1679 a3DView->SetZClippingType(V3d_FRONT);
1680
1681 a3DView->Redraw();
1682
1683 X_ButtonPress = X_Motion;
1684 Y_ButtonPress = Y_Motion;
1685 }
1686}
1687
1688//==============================================================================
1689//function : ProcessControlButton1Motion
1690//purpose : Zoom
1691//==============================================================================
1692
900f7229 1693#if defined(_WIN32) || ! defined(__APPLE__) || defined(MACOSX_USE_GLX)
7fd59977 1694static void ProcessControlButton1Motion()
1695{
1696 ViewerTest::CurrentView()->Zoom( X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion);
1697
1698 X_ButtonPress = X_Motion;
1699 Y_ButtonPress = Y_Motion;
1700}
900f7229 1701#endif
7fd59977 1702
1703//==============================================================================
4fe56619 1704//function : VT_ProcessControlButton2Motion
1705//purpose : Panning
7fd59977 1706//==============================================================================
4fe56619 1707void VT_ProcessControlButton2Motion()
7fd59977 1708{
197ac94e 1709 Standard_Integer aDx = X_Motion - X_ButtonPress;
1710 Standard_Integer aDy = Y_Motion - Y_ButtonPress;
7fd59977 1711
197ac94e 1712 aDy = -aDy; // Xwindow Y axis is from top to Bottom
7fd59977 1713
197ac94e 1714 ViewerTest::CurrentView()->Pan (aDx, aDy);
7fd59977 1715
1716 X_ButtonPress = X_Motion;
1717 Y_ButtonPress = Y_Motion;
1718}
1719
1720//==============================================================================
4fe56619 1721//function : VT_ProcessControlButton3Motion
7fd59977 1722//purpose : Rotation
1723//==============================================================================
4fe56619 1724void VT_ProcessControlButton3Motion()
7fd59977 1725{
4fe56619 1726 if (Start_Rot)
1727 {
1728 ViewerTest::CurrentView()->Rotation (X_Motion, Y_Motion);
1729 }
7fd59977 1730}
1731
1732//==============================================================================
4fe56619 1733//function : VT_ProcessMotion
1734//purpose :
7fd59977 1735//==============================================================================
4fe56619 1736void VT_ProcessMotion()
7fd59977 1737{
1738 //pre-hilights detected objects at mouse position
1739
1740 Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
1741 EM->MoveTo(X_Motion, Y_Motion);
1742}
1743
1744
1745void ViewerTest::GetMousePosition(Standard_Integer& Xpix,Standard_Integer& Ypix)
1746{
1747 Xpix = X_Motion;Ypix=Y_Motion;
1748}
1749
44b8f2d6 1750//==============================================================================
1751//function : ViewProject: implements VAxo, VTop, VLeft, ...
1752//purpose : Switches to an axonometric, top, left and other views
1753//==============================================================================
1754
1755static int ViewProject(Draw_Interpretor& di, const V3d_TypeOfOrientation ori)
1756{
4fe56619 1757 if ( ViewerTest::CurrentView().IsNull() )
44b8f2d6 1758 {
1759 di<<"Call vinit before this command, please"<<"\n";
1760 return 1;
1761 }
1762
1763 ViewerTest::CurrentView()->SetProj(ori);
1764 return 0;
1765}
1766
7fd59977 1767//==============================================================================
1768//function : VAxo
1769//purpose : Switch to an Axonometric view
1770//Draw arg : No args
1771//==============================================================================
1772
1773static int VAxo(Draw_Interpretor& di, Standard_Integer , const char** )
44b8f2d6 1774{
1775 return ViewProject(di, V3d_XposYnegZpos);
7fd59977 1776}
1777
1778//==============================================================================
1779//function : VTop
1780//purpose : Switch to a Top View
1781//Draw arg : No args
1782//==============================================================================
1783
1784static int VTop(Draw_Interpretor& di, Standard_Integer , const char** )
1785{
44b8f2d6 1786 return ViewProject(di, V3d_Zpos);
1787}
7fd59977 1788
44b8f2d6 1789//==============================================================================
1790//function : VBottom
1791//purpose : Switch to a Bottom View
1792//Draw arg : No args
1793//==============================================================================
7fd59977 1794
44b8f2d6 1795static int VBottom(Draw_Interpretor& di, Standard_Integer , const char** )
1796{
1797 return ViewProject(di, V3d_Zneg);
1798}
7fd59977 1799
44b8f2d6 1800//==============================================================================
1801//function : VLeft
1802//purpose : Switch to a Left View
1803//Draw arg : No args
1804//==============================================================================
1805
1806static int VLeft(Draw_Interpretor& di, Standard_Integer , const char** )
1807{
1808 return ViewProject(di, V3d_Ypos);
1809}
1810
1811//==============================================================================
1812//function : VRight
1813//purpose : Switch to a Right View
1814//Draw arg : No args
1815//==============================================================================
1816
1817static int VRight(Draw_Interpretor& di, Standard_Integer , const char** )
1818{
1819 return ViewProject(di, V3d_Yneg);
1820}
7fd59977 1821
44b8f2d6 1822//==============================================================================
1823//function : VFront
1824//purpose : Switch to a Front View
1825//Draw arg : No args
1826//==============================================================================
1827
1828static int VFront(Draw_Interpretor& di, Standard_Integer , const char** )
1829{
1830 return ViewProject(di, V3d_Xpos);
1831}
1832
1833//==============================================================================
1834//function : VBack
1835//purpose : Switch to a Back View
1836//Draw arg : No args
1837//==============================================================================
1838
1839static int VBack(Draw_Interpretor& di, Standard_Integer , const char** )
1840{
1841 return ViewProject(di, V3d_Xneg);
7fd59977 1842}
1843
1844//==============================================================================
1845//function : VHelp
1846//purpose : Dsiplay help on viewer Keyboead and mouse commands
1847//Draw arg : No args
1848//==============================================================================
1849
1850static int VHelp(Draw_Interpretor& di, Standard_Integer , const char** )
1851{
1852
1853 di << "Q : Quit the application" << "\n";
1854
1855 di << "========================="<<"\n";
1856 di << "F : FitAll" << "\n";
1857 di << "T : TopView" << "\n";
41811896 1858 di << "B : BottomView" << "\n";
1859 di << "R : RightView" << "\n";
1860 di << "L : LeftView" << "\n";
7fd59977 1861 di << "A : AxonometricView" << "\n";
41811896 1862 di << "D : ResetView" << "\n";
7fd59977 1863
1864 di << "========================="<<"\n";
1865 di << "S : Shading" << "\n";
1866 di << "W : Wireframe" << "\n";
1867 di << "H : HidelLineRemoval" << "\n";
41811896 1868 di << "U : Unset display mode" << "\n";
b514beda 1869 di << "Delete : Remove selection from viewer" << "\n";
7fd59977 1870
1871 di << "========================="<<"\n";
1872 di << "Selection mode "<<"\n";
1873 di << "0 : Shape" <<"\n";
1874 di << "1 : Vertex" <<"\n";
1875 di << "2 : Edge" <<"\n";
1876 di << "3 : Wire" <<"\n";
1877 di << "4 : Face" <<"\n";
1878 di << "5 : Shell" <<"\n";
1879 di << "6 : Solid" <<"\n";
1880 di << "7 : Compound" <<"\n";
1881
41811896 1882 di << "========================="<<"\n";
1883 di << "Z : Switch Z clipping On/Off" << "\n";
1884 di << ", : Hilight next detected" << "\n";
1885 di << ". : Hilight previous detected" << "\n";
7fd59977 1886
1887 return 0;
1888}
1889
7fd59977 1890#ifdef WNT
1891
1892static Standard_Boolean Ppick = 0;
1893static Standard_Integer Pargc = 0;
1894static const char** Pargv = NULL;
1895
1896
1897static LRESULT WINAPI AdvViewerWindowProc( HWND hwnd,
1898 UINT Msg,
1899 WPARAM wParam,
1900 LPARAM lParam )
1901{
18d715bd 1902 if (!ViewerTest_myViews.IsEmpty()) {
7fd59977 1903
1904 WPARAM fwKeys = wParam;
1905
1906 switch( Msg ) {
18d715bd 1907 case WM_CLOSE:
1908 {
1909 // Delete view from map of views
1910 ViewerTest::RemoveView(FindViewIdByWindowHandle(hwnd));
1911 return 0;
1912 }
1913 break;
1914 case WM_ACTIVATE:
1915 if(LOWORD(wParam) == WA_CLICKACTIVE || LOWORD(wParam) == WA_ACTIVE
1916 || ViewerTest::CurrentView().IsNull())
1917 {
1918 // Activate inactive window
1919 if(GetWindowHandle(VT_GetWindow()) != hwnd)
1920 {
1921 ActivateView (FindViewIdByWindowHandle(hwnd));
1922 }
1923 }
1924 break;
7fd59977 1925 case WM_LBUTTONUP:
8abada55 1926 if (!DragFirst)
7fd59977 1927 {
1928 HDC hdc = GetDC( hwnd );
7fd59977 1929 SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
1930 SetROP2( hdc, R2_NOT );
4fe56619 1931 Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
7fd59977 1932 ReleaseDC( hwnd, hdc );
8abada55 1933 VT_ProcessButton1Release (fwKeys & MK_SHIFT);
7fd59977 1934 }
8abada55 1935 IsDragged = Standard_False;
7fd59977 1936 return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1937
1938 case WM_LBUTTONDOWN:
1939 if( fwKeys == MK_LBUTTON || fwKeys == ( MK_LBUTTON | MK_SHIFT ) )
1940 {
1941 IsDragged = Standard_True;
1942 DragFirst = Standard_True;
4fe56619 1943 X_ButtonPress = LOWORD(lParam);
1944 Y_ButtonPress = HIWORD(lParam);
7fd59977 1945 }
1946 return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1947
1948 break;
1949
1950 case WM_MOUSEMOVE:
1951 if( IsDragged )
1952 {
1953 HDC hdc = GetDC( hwnd );
1954
1955 HGDIOBJ anObj = SelectObject( hdc, GetStockObject( WHITE_PEN ) );
1956 SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
1957 SetROP2( hdc, R2_NOT );
1958
1959 if( !DragFirst )
4fe56619 1960 Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
7fd59977 1961
1962 DragFirst = Standard_False;
4fe56619 1963 X_Motion = LOWORD(lParam);
1964 Y_Motion = HIWORD(lParam);
7fd59977 1965
4fe56619 1966 Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
7fd59977 1967
1968 SelectObject( hdc, anObj );
1969
1970 ReleaseDC( hwnd, hdc );
1971 }
1972 else
1973 return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1974 break;
1975
1976 default:
1977 return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1978 }
1979 return 0;
1980 }
1981 return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1982}
1983
1984
1985static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
1986 UINT Msg,
1987 WPARAM wParam,
1988 LPARAM lParam )
1989{
7fd59977 1990 static int Up = 1;
1991
1992 if ( !ViewerTest::CurrentView().IsNull() ) {
1993 PAINTSTRUCT ps;
1994
1995 switch( Msg ) {
7fd59977 1996 case WM_PAINT:
7fd59977 1997 BeginPaint(hwnd, &ps);
1998 EndPaint(hwnd, &ps);
4fe56619 1999 VT_ProcessExpose();
7fd59977 2000 break;
2001
2002 case WM_SIZE:
4fe56619 2003 VT_ProcessConfigure();
7fd59977 2004 break;
2005
2006 case WM_KEYDOWN:
4fe56619 2007 if ((wParam != VK_SHIFT) && (wParam != VK_CONTROL))
2008 {
7fd59977 2009 char c[2];
2010 c[0] = (char) wParam;
2011 c[1] = '\0';
b514beda 2012 if (wParam == VK_DELETE)
2013 {
2014 c[0] = THE_KEY_DELETE;
2015 }
4fe56619 2016 VT_ProcessKeyPress (c);
7fd59977 2017 }
2018 break;
2019
2020 case WM_LBUTTONUP:
2021 case WM_MBUTTONUP:
2022 case WM_RBUTTONUP:
7fd59977 2023 Up = 1;
4fe56619 2024 VT_ProcessButton3Release();
7fd59977 2025 break;
2026
2027 case WM_LBUTTONDOWN:
2028 case WM_MBUTTONDOWN:
2029 case WM_RBUTTONDOWN:
2030 {
7fd59977 2031 WPARAM fwKeys = wParam;
2032
2033 Up = 0;
2034
2035 X_ButtonPress = LOWORD(lParam);
2036 Y_ButtonPress = HIWORD(lParam);
2037
4fe56619 2038 if (Msg == WM_LBUTTONDOWN)
2039 {
2040 if (fwKeys & MK_CONTROL)
2041 {
2042 Ppick = VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT));
2043 }
2044 else
2045 {
2046 VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT));
2047 }
7fd59977 2048 }
4fe56619 2049 else if (Msg == WM_RBUTTONDOWN)
2050 {
7fd59977 2051 // Start rotation
4fe56619 2052 VT_ProcessButton3Press();
7fd59977 2053 }
2054 }
2055 break;
2056
2057 case WM_MOUSEMOVE:
2058 {
2059 //cout << "\t WM_MOUSEMOVE" << endl;
2060 WPARAM fwKeys = wParam;
2061 X_Motion = LOWORD(lParam);
2062 Y_Motion = HIWORD(lParam);
2063
2064 if ( Up &&
2065 fwKeys & ( MK_LBUTTON|MK_MBUTTON|MK_RBUTTON ) ) {
2066 Up = 0;
2067 X_ButtonPress = LOWORD(lParam);
2068 Y_ButtonPress = HIWORD(lParam);
2069
2070 if ( fwKeys & MK_RBUTTON ) {
2071 // Start rotation
4fe56619 2072 VT_ProcessButton3Press();
7fd59977 2073 }
2074 }
2075
2076 if ( fwKeys & MK_CONTROL ) {
2077 if ( fwKeys & MK_LBUTTON ) {
2078 ProcessControlButton1Motion();
2079 }
2080 else if ( fwKeys & MK_MBUTTON ||
2081 ((fwKeys&MK_LBUTTON) &&
2082 (fwKeys&MK_RBUTTON) ) ){
4fe56619 2083 VT_ProcessControlButton2Motion();
7fd59977 2084 }
2085 else if ( fwKeys & MK_RBUTTON ) {
4fe56619 2086 VT_ProcessControlButton3Motion();
7fd59977 2087 }
2088 }
2089#ifdef BUG
2090 else if ( fwKeys & MK_SHIFT ) {
2091 if ( fwKeys & MK_MBUTTON ||
2092 ((fwKeys&MK_LBUTTON) &&
2093 (fwKeys&MK_RBUTTON) ) ) {
2094 cout << "ProcessZClipMotion()" << endl;
2095 ProcessZClipMotion();
2096 }
2097 }
2098#endif
08398024 2099 else if (GetWindowHandle (VT_GetWindow()) == hwnd)
2100 {
4fe56619 2101 if ((fwKeys & MK_MBUTTON
2102 || ((fwKeys & MK_LBUTTON) && (fwKeys & MK_RBUTTON))))
2103 {
7fd59977 2104 ProcessZClipMotion();
2105 }
4fe56619 2106 else
2107 {
2108 VT_ProcessMotion();
7fd59977 2109 }
08398024 2110 }
7fd59977 2111 }
2112 break;
2113
2114 default:
2115 return( DefWindowProc( hwnd, Msg, wParam, lParam ));
2116 }
2117 return 0L;
2118 }
2119
2120 return DefWindowProc( hwnd, Msg, wParam, lParam );
2121}
2122
2123
2124
2125
2126//==============================================================================
2127//function : ViewerMainLoop
2128//purpose : Get a Event on the view and dispatch it
2129//==============================================================================
2130
2131
8263fcd3 2132int ViewerMainLoop(Standard_Integer argc, const char** argv)
7fd59977 2133{
7fd59977 2134 Ppick = (argc > 0)? 1 : 0;
2135 Pargc = argc;
2136 Pargv = argv;
2137
2138 if ( Ppick ) {
2139 MSG msg;
2140 msg.wParam = 1;
2141
2142 cout << "Start picking" << endl;
2143
7fd59977 2144 while ( Ppick == 1 ) {
4fe56619 2145 // Wait for a VT_ProcessButton1Press() to toggle pick to 1 or 0
7fd59977 2146 if (GetMessage(&msg, NULL, 0, 0) ) {
2147 TranslateMessage(&msg);
2148 DispatchMessage(&msg);
2149 }
2150 }
2151
2152 cout << "Picking done" << endl;
2153 }
2154
2155 return Ppick;
2156}
2157
4fe56619 2158#elif !defined(__APPLE__) || defined(MACOSX_USE_GLX)
7fd59977 2159
2160int min( int a, int b )
2161{
2162 if( a<b )
2163 return a;
2164 else
2165 return b;
2166}
2167
2168int max( int a, int b )
2169{
2170 if( a>b )
2171 return a;
2172 else
2173 return b;
2174}
2175
2176int ViewerMainLoop(Standard_Integer argc, const char** argv)
2177
4269bd1b 2178{
18d715bd 2179 static XEvent aReport;
2180 Standard_Boolean pick = argc > 0;
2181 Display *aDisplay = GetDisplayConnection()->GetDisplay();
2182 XNextEvent (aDisplay, &aReport);
7fd59977 2183
18d715bd 2184 // Handle event for the chosen display connection
2185 switch (aReport.type) {
2186 case ClientMessage:
2187 {
eb1ebea4 2188 if((Atom)aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
18d715bd 2189 {
2190 // Close the window
2191 ViewerTest::RemoveView(FindViewIdByWindowHandle (aReport.xclient.window));
2192 }
2193 }
2194 return 0;
2195 case FocusIn:
2196 {
2197 // Activate inactive view
2198 Window aWindow = GetWindowHandle(VT_GetWindow());
2199 if(aWindow != aReport.xfocus.window)
2200 {
2201 ActivateView (FindViewIdByWindowHandle (aReport.xfocus.window));
2202 }
2203 }
2204 break;
7fd59977 2205 case Expose:
2206 {
4fe56619 2207 VT_ProcessExpose();
7fd59977 2208 }
2209 break;
2210 case ConfigureNotify:
2211 {
4fe56619 2212 VT_ProcessConfigure();
7fd59977 2213 }
2214 break;
2215 case KeyPress:
2216 {
2217
2218 KeySym ks_ret ;
2219 char buf_ret[11] ;
2220 int ret_len ;
2221 XComposeStatus status_in_out;
2222
18d715bd 2223 ret_len = XLookupString( ( XKeyEvent *)&aReport ,
7fd59977 2224 (char *) buf_ret , 10 ,
2225 &ks_ret , &status_in_out ) ;
2226
2227
2228 buf_ret[ret_len] = '\0' ;
2229
4fe56619 2230 if (ret_len)
2231 {
2232 VT_ProcessKeyPress (buf_ret);
7fd59977 2233 }
2234 }
2235 break;
2236 case ButtonPress:
7fd59977 2237 {
18d715bd 2238 X_ButtonPress = aReport.xbutton.x;
2239 Y_ButtonPress = aReport.xbutton.y;
7fd59977 2240
18d715bd 2241 if (aReport.xbutton.button == Button1)
4fe56619 2242 {
18d715bd 2243 if (aReport.xbutton.state & ControlMask)
4fe56619 2244 {
18d715bd 2245 pick = VT_ProcessButton1Press (argc, argv, pick, (aReport.xbutton.state & ShiftMask));
4fe56619 2246 }
7fd59977 2247 else
2248 {
2249 IsDragged = Standard_True;
7fd59977 2250 DragFirst = Standard_True;
2251 }
4fe56619 2252 }
18d715bd 2253 else if (aReport.xbutton.button == Button3)
4fe56619 2254 {
7fd59977 2255 // Start rotation
4fe56619 2256 VT_ProcessButton3Press();
2257 }
7fd59977 2258 }
2259 break;
2260 case ButtonRelease:
2261 {
7fd59977 2262 if( IsDragged )
2263 {
2264 if( !DragFirst )
2265 {
2266 Aspect_Handle aWindow = VT_GetWindow()->XWindow();
18d715bd 2267 GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
2268 XDrawRectangle( aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
7fd59977 2269 }
2270
2271 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
2272 if( aContext.IsNull() )
2273 {
2274 cout << "The context is null. Please use vinit before createmesh" << endl;
2275 return 0;
2276 }
2277
18d715bd 2278 Standard_Boolean ShiftPressed = ( aReport.xbutton.state & ShiftMask );
2279 if( aReport.xbutton.button==1 )
7fd59977 2280 if( DragFirst )
2281 if( ShiftPressed )
2282 {
2283 aContext->ShiftSelect();
7fd59977 2284 }
2285 else
2286 {
2287 aContext->Select();
7fd59977 2288 }
2289 else
2290 if( ShiftPressed )
2291 {
4fe56619 2292 aContext->ShiftSelect( min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ),
2293 max( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
7fd59977 2294 ViewerTest::CurrentView());
7fd59977 2295 }
2296 else
2297 {
4fe56619 2298 aContext->Select( min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ),
2299 max( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
7fd59977 2300 ViewerTest::CurrentView() );
7fd59977 2301 }
2302 else
4fe56619 2303 VT_ProcessButton3Release();
7fd59977 2304
2305 IsDragged = Standard_False;
2306 }
2307 else
4fe56619 2308 VT_ProcessButton3Release();
7fd59977 2309 }
2310 break;
2311 case MotionNotify:
2312 {
08398024 2313 if (GetWindowHandle (VT_GetWindow()) != aReport.xmotion.window)
2314 {
2315 break;
2316 }
7fd59977 2317 if( IsDragged )
2318 {
2319 Aspect_Handle aWindow = VT_GetWindow()->XWindow();
18d715bd 2320 GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
2321 XSetFunction( aDisplay, gc, GXinvert );
7fd59977 2322
2323 if( !DragFirst )
18d715bd 2324 XDrawRectangle(aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
7fd59977 2325
18d715bd 2326 X_Motion = aReport.xmotion.x;
2327 Y_Motion = aReport.xmotion.y;
7fd59977 2328 DragFirst = Standard_False;
2329
18d715bd 2330 XDrawRectangle( aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
7fd59977 2331 }
2332 else
2333 {
18d715bd 2334 X_Motion = aReport.xmotion.x;
2335 Y_Motion = aReport.xmotion.y;
7fd59977 2336
18d715bd 2337 // remove all the ButtonMotionMaskr
2338 while( XCheckMaskEvent( aDisplay, ButtonMotionMask, &aReport) ) ;
7fd59977 2339
18d715bd 2340 if ( ZClipIsOn && aReport.xmotion.state & ShiftMask ) {
7fd59977 2341 if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
2342
2343 Quantity_Length VDX, VDY;
2344
2345 ViewerTest::CurrentView()->Size(VDX,VDY);
2346 Standard_Real VDZ =0 ;
2347 VDZ = ViewerTest::CurrentView()->ZSize();
2348
7fd59977 2349 printf("%f,%f,%f\n", VDX, VDY, VDZ);
2350
2351 Quantity_Length dx = 0 ;
2352 dx = ViewerTest::CurrentView()->Convert(X_Motion - X_ButtonPress);
2353
2354 cout << dx << endl;
2355
2356 dx = dx / VDX * VDZ;
2357
2358 cout << dx << endl;
2359
7fd59977 2360 ViewerTest::CurrentView()->Redraw();
2361 }
2362 }
2363
18d715bd 2364 if ( aReport.xmotion.state & ControlMask ) {
2365 if ( aReport.xmotion.state & Button1Mask ) {
7fd59977 2366 ProcessControlButton1Motion();
2367 }
18d715bd 2368 else if ( aReport.xmotion.state & Button2Mask ) {
4fe56619 2369 VT_ProcessControlButton2Motion();
7fd59977 2370 }
18d715bd 2371 else if ( aReport.xmotion.state & Button3Mask ) {
4fe56619 2372 VT_ProcessControlButton3Motion();
7fd59977 2373 }
2374 }
4fe56619 2375 else
2376 {
2377 VT_ProcessMotion();
7fd59977 2378 }
2379 }
2380 }
2381 break;
2382}
7fd59977 2383return pick;
2384}
2385
2386//==============================================================================
2387//function : VProcessEvents
2388//purpose : call by Tk_CreateFileHandler() to be able to manage the
2389// event in the Viewer window
2390//==============================================================================
2391
2392static void VProcessEvents(ClientData,int)
2393{
18d715bd 2394 NCollection_Vector<int> anEventNumbers;
2395 // Get number of messages from every display
2396 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
2397 anIter (ViewerTest_myDrivers); anIter.More(); anIter.Next())
2398 {
2399 anEventNumbers.Append(XPending (anIter.Key2()->GetDisplayConnection()->GetDisplay()));
4269bd1b 2400 }
18d715bd 2401 // Handle events for every display
2402 int anEventIter = 0;
2403 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
2404 anIter (ViewerTest_myDrivers); anIter.More(); anIter.Next(), anEventIter++)
2405 {
4269bd1b 2406 for (int i = 0; i < anEventNumbers.Value(anEventIter) &&
18d715bd 2407 XPending (anIter.Key2()->GetDisplayConnection()->GetDisplay()) > 0; ++i)
2408 {
2409 SetDisplayConnection (anIter.Key2()->GetDisplayConnection());
2410 int anEventResult = ViewerMainLoop( 0, NULL);
2411 // If window is closed or context was not found finish current event processing loop
2412 if (!anEventResult)
2413 return;
2414 }
7fd59977 2415 }
4269bd1b 2416
18d715bd 2417 SetDisplayConnection (ViewerTest::GetAISContext()->CurrentViewer()->Driver()->GetDisplayConnection());
4269bd1b 2418
7fd59977 2419}
2420#endif
2421
2422//==============================================================================
2423//function : OSWindowSetup
2424//purpose : Setup for the X11 window to be able to cath the event
2425//==============================================================================
2426
2427
2428static void OSWindowSetup()
2429{
4fe56619 2430#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
7fd59977 2431 // X11
2432
2433 Window window = VT_GetWindow()->XWindow();
18d715bd 2434 SetDisplayConnection (ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
2435 Display *aDisplay = GetDisplayConnection()->GetDisplay();
2436 XSynchronize(aDisplay, 1);
7fd59977 2437
2438 // X11 : For keyboard on SUN
2439 XWMHints wmhints;
2440 wmhints.flags = InputHint;
2441 wmhints.input = 1;
2442
18d715bd 2443 XSetWMHints( aDisplay, window, &wmhints);
7fd59977 2444
18d715bd 2445 XSelectInput( aDisplay, window, ExposureMask | KeyPressMask |
7fd59977 2446 ButtonPressMask | ButtonReleaseMask |
2447 StructureNotifyMask |
2448 PointerMotionMask |
2449 Button1MotionMask | Button2MotionMask |
18d715bd 2450 Button3MotionMask | FocusChangeMask
7fd59977 2451 );
18d715bd 2452 Atom aDeleteWindowAtom = GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW);
2453 XSetWMProtocols(aDisplay, window, &aDeleteWindowAtom, 1);
7fd59977 2454
18d715bd 2455 XSynchronize(aDisplay, 0);
7fd59977 2456
2457#else
2458 // WNT
2459#endif
2460
2461}
2462
2463
2464//==============================================================================
2465//function : VFit
2466
2467//purpose : Fitall, no DRAW arguments
2468//Draw arg : No args
2469//==============================================================================
2470
2471static int VFit(Draw_Interpretor& , Standard_Integer , const char** )
2472{
2473 const Handle(V3d_View) aView = ViewerTest::CurrentView();
2474 Handle(NIS_View) V = Handle(NIS_View)::DownCast(aView);
2475 if (V.IsNull() == Standard_False) {
2476 V->FitAll3d();
2477 } else if (aView.IsNull() == Standard_False) {
2478 aView->FitAll();
2479 }
2480 return 0;
2481}
2482
6262a303 2483//=======================================================================
2484//function : VFitArea
2485//purpose : Fit view to show area located between two points
2486// : given in world 2D or 3D coordinates.
2487//=======================================================================
2488static int VFitArea (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
2489{
2490 Handle(V3d_View) aView = ViewerTest::CurrentView();
2491 if (aView.IsNull())
2492 {
2493 std::cerr << theArgVec[0] << "Error: No active view.\n";
2494 return 1;
2495 }
2496
2497 // Parse arguments.
2498 gp_Pnt aWorldPnt1 (0.0, 0.0, 0.0);
2499 gp_Pnt aWorldPnt2 (0.0, 0.0, 0.0);
2500
2501 if (theArgNb == 5)
2502 {
2503 aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
2504 aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
2505 aWorldPnt2.SetX (Draw::Atof (theArgVec[3]));
2506 aWorldPnt2.SetY (Draw::Atof (theArgVec[4]));
2507 }
2508 else if (theArgNb == 7)
2509 {
2510 aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
2511 aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
2512 aWorldPnt1.SetZ (Draw::Atof (theArgVec[3]));
2513 aWorldPnt2.SetX (Draw::Atof (theArgVec[4]));
2514 aWorldPnt2.SetY (Draw::Atof (theArgVec[5]));
2515 aWorldPnt2.SetZ (Draw::Atof (theArgVec[6]));
2516 }
2517 else
2518 {
2519 std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
2520 theDI.PrintHelp(theArgVec[0]);
2521 return 1;
2522 }
2523
2524 // Convert model coordinates to view space
2525 Handle(Graphic3d_Camera) aCamera = aView->Camera();
2526 gp_Pnt aViewPnt1 = aCamera->ConvertWorld2View (aWorldPnt1);
2527 gp_Pnt aViewPnt2 = aCamera->ConvertWorld2View (aWorldPnt2);
2528
2529 // Determine fit area
2530 gp_Pnt2d aMinCorner (Min (aViewPnt1.X(), aViewPnt2.X()), Min (aViewPnt1.Y(), aViewPnt2.Y()));
2531 gp_Pnt2d aMaxCorner (Max (aViewPnt1.X(), aViewPnt2.X()), Max (aViewPnt1.Y(), aViewPnt2.Y()));
2532
2533 Standard_Real aDiagonal = aMinCorner.Distance (aMaxCorner);
2534
2535 if (aDiagonal < Precision::Confusion())
2536 {
2537 std::cerr << theArgVec[0] << "Error: view area is too small.\n";
2538 return 1;
2539 }
2540
2541 aView->FitAll (aMinCorner.X(), aMinCorner.Y(), aMaxCorner.X(), aMaxCorner.Y());
2542 return 0;
2543}
2544
7fd59977 2545//==============================================================================
2546//function : VZFit
2547//purpose : ZFitall, no DRAW arguments
2548//Draw arg : No args
2549//==============================================================================
197ac94e 2550static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
7fd59977 2551{
197ac94e 2552 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
2553
2554 if (aCurrentView.IsNull())
2555 {
2556 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
2557 return 1;
2558 }
2559
2560 if (theArgsNb == 1)
2561 {
6bc6a6fc 2562 aCurrentView->View()->ZFitAll();
197ac94e 2563 aCurrentView->Redraw();
2564 return 0;
2565 }
2566
2567 Standard_Real aScale = 1.0;
2568
2569 if (theArgsNb >= 2)
2570 {
2571 aScale = Draw::Atoi (theArgVec[1]);
2572 }
2573
6bc6a6fc 2574 aCurrentView->View()->ZFitAll (aScale);
197ac94e 2575 aCurrentView->Redraw();
7fd59977 2576
197ac94e 2577 return 0;
2578}
7fd59977 2579
197ac94e 2580//==============================================================================
2581//function : VRepaint
2582//purpose :
2583//==============================================================================
2584static int VRepaint (Draw_Interpretor& , Standard_Integer , const char** )
7fd59977 2585{
2586 Handle(V3d_View) V = ViewerTest::CurrentView();
2587 if ( !V.IsNull() ) V->Redraw(); return 0;
2588}
2589
7fd59977 2590//==============================================================================
2591//function : VClear
2592//purpose : Remove all the object from the viewer
2593//Draw arg : No args
2594//==============================================================================
2595
2596static int VClear(Draw_Interpretor& , Standard_Integer , const char** )
2597{
2598 Handle(V3d_View) V = ViewerTest::CurrentView();
2599 if(!V.IsNull())
2600 ViewerTest::Clear();
2601 return 0;
2602}
2603
2604//==============================================================================
2605//function : VPick
2606//purpose :
2607//==============================================================================
2608
2609static int VPick(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2610{ if (ViewerTest::CurrentView().IsNull() ) return 1;
2611
2612if ( argc < 4 ) {
2613 di << argv[0] << "Invalid number of arguments" << "\n";
2614 return 1;
2615}
2616
2617while (ViewerMainLoop( argc, argv)) {
2618}
2619
2620return 0;
2621}
2622
7fd59977 2623//==============================================================================
2624//function : VSetBg
2625//purpose : Load image as background
2626//==============================================================================
2627
2628static int VSetBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2629{
2630 if (argc < 2 || argc > 3)
2631 {
2632 di << "Usage : " << argv[0] << " imagefile [filltype] : Load image as background" << "\n";
f8b2ed36 2633 di << "filltype can be one of CENTERED, TILED, STRETCH, NONE" << "\n";
7fd59977 2634 return 1;
2635 }
2636
2637 Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2638 if(AISContext.IsNull())
2639 {
2640 di << "use 'vinit' command before " << argv[0] << "\n";
2641 return 1;
2642 }
2643
2644 Aspect_FillMethod aFillType = Aspect_FM_CENTERED;
2645 if (argc == 3)
2646 {
2647 const char* szType = argv[2];
2648 if (strcmp(szType, "NONE" ) == 0) aFillType = Aspect_FM_NONE;
2649 else if (strcmp(szType, "CENTERED") == 0) aFillType = Aspect_FM_CENTERED;
2650 else if (strcmp(szType, "TILED" ) == 0) aFillType = Aspect_FM_TILED;
2651 else if (strcmp(szType, "STRETCH" ) == 0) aFillType = Aspect_FM_STRETCH;
2652 else
2653 {
2654 di << "Wrong fill type : " << szType << "\n";
2655 di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2656 return 1;
2657 }
2658 }
2659
2660 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2661 V3dView->SetBackgroundImage(argv[1], aFillType, Standard_True);
2662
2663 return 0;
2664}
2665
f8b2ed36 2666//==============================================================================
2667//function : VSetBgMode
2668//purpose : Change background image fill type
2669//==============================================================================
2670
2671static int VSetBgMode(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2672{
2673 if (argc != 2)
2674 {
2675 di << "Usage : " << argv[0] << " filltype : Change background image mode" << "\n";
2676 di << "filltype must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2677 return 1;
2678 }
2679
2680 Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2681 if(AISContext.IsNull())
2682 {
2683 di << "use 'vinit' command before " << argv[0] << "\n";
2684 return 1;
2685 }
1d47d8d0 2686 Aspect_FillMethod aFillType = Aspect_FM_NONE;
2687 const char* szType = argv[1];
2688 if (strcmp(szType, "NONE" ) == 0) aFillType = Aspect_FM_NONE;
2689 else if (strcmp(szType, "CENTERED") == 0) aFillType = Aspect_FM_CENTERED;
2690 else if (strcmp(szType, "TILED" ) == 0) aFillType = Aspect_FM_TILED;
2691 else if (strcmp(szType, "STRETCH" ) == 0) aFillType = Aspect_FM_STRETCH;
2692 else
f8b2ed36 2693 {
1d47d8d0 2694 di << "Wrong fill type : " << szType << "\n";
2695 di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2696 return 1;
f8b2ed36 2697 }
f8b2ed36 2698 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2699 V3dView->SetBgImageStyle(aFillType, Standard_True);
f8b2ed36 2700 return 0;
2701}
2702
7fd59977 2703//==============================================================================
2704//function : VSetGradientBg
2705//purpose : Mount gradient background
2706//==============================================================================
2707static int VSetGradientBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2708{
2709 if (argc != 8 )
2710 {
2711 di << "Usage : " << argv[0] << " R1 G1 B1 R2 G2 B2 Type : Mount gradient background" << "\n";
2712 di << "R1,G1,B1,R2,G2,B2 = [0..255]" << "\n";
2713 di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2714 di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2715 return 1;
2716 }
2717
2718 Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2719 if(AISContext.IsNull())
2720 {
2721 di << "use 'vinit' command before " << argv[0] << "\n";
2722 return 1;
2723 }
2724 if (argc == 8)
2725 {
2726
91322f44 2727 Standard_Real R1 = Draw::Atof(argv[1])/255.;
2728 Standard_Real G1 = Draw::Atof(argv[2])/255.;
2729 Standard_Real B1 = Draw::Atof(argv[3])/255.;
7fd59977 2730 Quantity_Color aColor1(R1,G1,B1,Quantity_TOC_RGB);
2731
91322f44 2732 Standard_Real R2 = Draw::Atof(argv[4])/255.;
2733 Standard_Real G2 = Draw::Atof(argv[5])/255.;
2734 Standard_Real B2 = Draw::Atof(argv[6])/255.;
7fd59977 2735
2736 Quantity_Color aColor2(R2,G2,B2,Quantity_TOC_RGB);
91322f44 2737 int aType = Draw::Atoi(argv[7]);
7fd59977 2738 if( aType < 0 || aType > 8 )
2739 {
2740 di << "Wrong fill type " << "\n";
2741 di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2742 di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2743 return 1;
2744 }
2745
2746 Aspect_GradientFillMethod aMethod = Aspect_GradientFillMethod(aType);
2747
2748 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2749 V3dView->SetBgGradientColors( aColor1, aColor2, aMethod, 1);
2750 }
2751
2752 return 0;
2753}
2754
f8b2ed36 2755//==============================================================================
2756//function : VSetGradientBgMode
2757//purpose : Change gradient background fill style
2758//==============================================================================
2759static int VSetGradientBgMode(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2760{
2761 if (argc != 2 )
2762 {
2763 di << "Usage : " << argv[0] << " Type : Change gradient background fill type" << "\n";
2764 di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2765 di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2766 return 1;
2767 }
2768
2769 Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2770 if(AISContext.IsNull())
2771 {
2772 di << "use 'vinit' command before " << argv[0] << "\n";
2773 return 1;
2774 }
2775 if (argc == 2)
2776 {
91322f44 2777 int aType = Draw::Atoi(argv[1]);
f8b2ed36 2778 if( aType < 0 || aType > 8 )
2779 {
2780 di << "Wrong fill type " << "\n";
2781 di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2782 di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2783 return 1;
2784 }
2785
2786 Aspect_GradientFillMethod aMethod = Aspect_GradientFillMethod(aType);
2787
2788 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2789 V3dView->SetBgGradientStyle( aMethod, 1 );
2790 }
2791
2792 return 0;
2793}
2794
2795//==============================================================================
2796//function : VSetColorBg
2797//purpose : Set color background
2798//==============================================================================
2799static int VSetColorBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2800{
2801 if (argc != 4 )
2802 {
2803 di << "Usage : " << argv[0] << " R G B : Set color background" << "\n";
2804 di << "R,G,B = [0..255]" << "\n";
2805 return 1;
2806 }
2807
2808 Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2809 if(AISContext.IsNull())
2810 {
2811 di << "use 'vinit' command before " << argv[0] << "\n";
2812 return 1;
2813 }
2814 if (argc == 4)
2815 {
2816
91322f44 2817 Standard_Real R = Draw::Atof(argv[1])/255.;
2818 Standard_Real G = Draw::Atof(argv[2])/255.;
2819 Standard_Real B = Draw::Atof(argv[3])/255.;
f8b2ed36 2820 Quantity_Color aColor(R,G,B,Quantity_TOC_RGB);
2821
2822 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2823 V3dView->SetBackgroundColor( aColor );
2824 V3dView->Update();
2825 }
2826
2827 return 0;
2828}
2829
7fd59977 2830//==============================================================================
2831//function : VScale
2832//purpose : View Scaling
2833//==============================================================================
2834
2835static int VScale(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2836{
2837 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2838 if ( V3dView.IsNull() ) return 1;
2839
2840 if ( argc != 4 ) {
2841 di << argv[0] << "Invalid number of arguments" << "\n";
2842 return 1;
2843 }
91322f44 2844 V3dView->SetAxialScale( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
7fd59977 2845 return 0;
2846}
2847//==============================================================================
2848//function : VTestZBuffTrihedron
7c8a8fcc 2849//purpose : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron
7fd59977 2850//==============================================================================
2851
2852static int VTestZBuffTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2853{
2854 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2855 if ( V3dView.IsNull() ) return 1;
2856
7fd59977 2857 V3dView->ZBufferTriedronSetup();
7c8a8fcc 2858
2859 if ( argc == 1 ) {
2860 // Set up default trihedron parameters
2861 V3dView->TriedronDisplay( Aspect_TOTP_LEFT_LOWER, Quantity_NOC_WHITE, 0.1, V3d_ZBUFFER );
2862 } else
2863 if ( argc == 7 )
2864 {
2865 Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
2866 const char* aPosType = argv[1];
2867
2868 if ( strcmp(aPosType, "center") == 0 )
2869 {
2870 aPosition = Aspect_TOTP_CENTER;
2871 } else
2872 if (strcmp(aPosType, "left_lower") == 0)
2873 {
2874 aPosition = Aspect_TOTP_LEFT_LOWER;
2875 } else
2876 if (strcmp(aPosType, "left_upper") == 0)
2877 {
2878 aPosition = Aspect_TOTP_LEFT_UPPER;
2879 } else
2880 if (strcmp(aPosType, "right_lower") == 0)
2881 {
2882 aPosition = Aspect_TOTP_RIGHT_LOWER;
2883 } else
2884 if (strcmp(aPosType, "right_upper") == 0)
2885 {
2886 aPosition = Aspect_TOTP_RIGHT_UPPER;
2887 } else
2888 {
2889 di << argv[1] << " Invalid type of alignment" << "\n";
2890 di << "Must be one of [ center, left_lower," << "\n";
2891 di << "left_upper, right_lower, right_upper ]" << "\n";
2892 return 1;
2893 }
2894
91322f44 2895 Standard_Real R = Draw::Atof(argv[2])/255.;
2896 Standard_Real G = Draw::Atof(argv[3])/255.;
2897 Standard_Real B = Draw::Atof(argv[4])/255.;
7c8a8fcc 2898 Quantity_Color aColor(R, G, B, Quantity_TOC_RGB);
2899
91322f44 2900 Standard_Real aScale = Draw::Atof(argv[5]);
7c8a8fcc 2901
2902 if( aScale <= 0.0 )
2903 {
2904 di << argv[5] << " Invalid value. Must be > 0" << "\n";
2905 return 1;
2906 }
2907
2908 V3d_TypeOfVisualization aPresentation = V3d_ZBUFFER;
2909 const char* aPresType = argv[6];
2910
2911 if ( strcmp(aPresType, "wireframe") == 0 )
2912 {
2913 aPresentation = V3d_WIREFRAME;
2914 } else
2915 if (strcmp(aPresType, "zbuffer") == 0)
2916 {
2917 aPresentation = V3d_ZBUFFER;
2918 } else
2919 {
2920 di << argv[6] << " Invalid type of visualization" << "\n";
2921 di << "Must be one of [ wireframe, zbuffer ]" << "\n";
2922 return 1;
2923 }
2924
2925 V3dView->TriedronDisplay( aPosition, aColor.Name(), aScale, aPresentation );
2926
2927 } else
2928 {
2929 di << argv[0] << " Invalid number of arguments" << "\n";
2930 return 1;
2931 }
2932
6bc6a6fc 2933 V3dView->View()->ZFitAll();
7c8a8fcc 2934
7fd59977 2935 return 0;
2936}
2937
2938//==============================================================================
2939//function : VRotate
2940//purpose : Camera Rotating
2941//==============================================================================
2942
2943static int VRotate( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
2944 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2945 if ( V3dView.IsNull() ) {
2946 return 1;
2947 }
2948
2949 if ( argc == 4 ) {
91322f44 2950 V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
7fd59977 2951 return 0;
2952 } else if ( argc == 7 ) {
91322f44 2953 V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]), Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]) );
7fd59977 2954 return 0;
2955 } else {
2956 di << argv[0] << " Invalid number of arguments" << "\n";
2957 return 1;
2958 }
2959}
2960
2961//==============================================================================
2962//function : VZoom
2963//purpose : View zoom in / out (relative to current zoom)
2964//==============================================================================
2965
2966static int VZoom( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
2967 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2968 if ( V3dView.IsNull() ) {
2969 return 1;
2970 }
2971
2972 if ( argc == 2 ) {
91322f44 2973 Standard_Real coef = Draw::Atof(argv[1]);
7fd59977 2974 if ( coef <= 0.0 ) {
2975 di << argv[1] << "Invalid value" << "\n";
2976 return 1;
2977 }
91322f44 2978 V3dView->SetZoom( Draw::Atof(argv[1]) );
7fd59977 2979 return 0;
2980 } else {
2981 di << argv[0] << " Invalid number of arguments" << "\n";
2982 return 1;
2983 }
2984}
2985
2986//==============================================================================
2987//function : VPan
2988//purpose : View panning (in pixels)
2989//==============================================================================
2990
2991static int VPan( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
2992 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2993 if ( V3dView.IsNull() ) return 1;
2994
2995 if ( argc == 3 ) {
91322f44 2996 V3dView->Pan( Draw::Atoi(argv[1]), Draw::Atoi(argv[2]) );
7fd59977 2997 return 0;
2998 } else {
2999 di << argv[0] << " Invalid number of arguments" << "\n";
3000 return 1;
3001 }
3002}
3003
3004
3005//==============================================================================
3006//function : VExport
5cedc27f 3007//purpose : Export the view to a vector graphic format (PS, EMF, PDF)
7fd59977 3008//==============================================================================
3009
3010static int VExport(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3011{
3012 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
5cedc27f
K		 3013 if (V3dView.IsNull())
3014 return 1;
7fd59977 3015
5cedc27f
K		 3016 if (argc == 1)
3017 {
3018 std::cout << "Usage: " << argv[0] << " Filename [Format]\n";
7fd59977 3019 return 1;
3020 }
3021
5cedc27f
K		 3022 Graphic3d_ExportFormat anExpFormat = Graphic3d_EF_PDF;
3023 TCollection_AsciiString aFormatStr;
3024
3025 TCollection_AsciiString aFileName (argv[1]);
3026 Standard_Integer aLen = aFileName.Length();
3027
3028 if (argc > 2)
3029 {
3030 aFormatStr = TCollection_AsciiString (argv[2]);
3031 }
3032 else if (aLen >= 4)
3033 {
3034 if (aFileName.Value (aLen - 2) == '.')
3035 {
3036 aFormatStr = aFileName.SubString (aLen - 1, aLen);
3037 }
3038 else if (aFileName.Value (aLen - 3) == '.')
3039 {
3040 aFormatStr = aFileName.SubString (aLen - 2, aLen);
3041 }
3042 else
3043 {
3044 std::cout << "Export format couln't be detected from filename '" << argv[1] << "'\n";
3045 return 1;
3046 }
3047 }
3048 else
3049 {
3050 std::cout << "Export format couln't be detected from filename '" << argv[1] << "'\n";
3051 return 1;
3052 }
3053
3054 aFormatStr.UpperCase();
3055 if (aFormatStr == "PS")
3056 anExpFormat = Graphic3d_EF_PostScript;
3057 else if (aFormatStr == "EPS")
3058 anExpFormat = Graphic3d_EF_EnhPostScript;
3059 else if (aFormatStr == "TEX")
3060 anExpFormat = Graphic3d_EF_TEX;
3061 else if (aFormatStr == "PDF")
3062 anExpFormat = Graphic3d_EF_PDF;
3063 else if (aFormatStr == "SVG")
3064 anExpFormat = Graphic3d_EF_SVG;
3065 else if (aFormatStr == "PGF")
3066 anExpFormat = Graphic3d_EF_PGF;
3067 else if (aFormatStr == "EMF")
3068 anExpFormat = Graphic3d_EF_EMF;
3069 else
3070 {
3071 std::cout << "Invalid export format '" << aFormatStr << "'\n";
3072 return 1;
3073 }
3074
9753e6de 3075 try {
3076 if (!V3dView->View()->Export (argv[1], anExpFormat))
3077 {
3078 di << "Error: export of image to " << aFormatStr << " failed!\n";
3079 }
3080 }
3081 catch (Standard_Failure)
5cedc27f 3082 {
9753e6de 3083 di << "Error: export of image to " << aFormatStr << " failed";
3084 di << " (exception: " << Standard_Failure::Caught()->GetMessageString() << ")";
5cedc27f 3085 }
7fd59977 3086 return 0;
3087}
3088
3089//==============================================================================
3090//function : VColorScale
3091//purpose : representation color scale
3092//==============================================================================
3093#include <V3d_ColorScale.hxx>
3094
3095static int VColorScale (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
3096{
3097 if ( argc != 1 && argc != 4 && argc != 5 && argc != 6 && argc != 8 )
3098 {
3099 di << "Usage : " << argv[0] << " [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = Right X = 0 Y = 0] " << "\n";
3100 return 1;
3101 }
3102
3103 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
3104 if(aContext.IsNull()) {
3105 di << argv[0] << " ERROR : use 'vinit' command before " << "\n";
3106 return -1;
3107 }
3108
3109 Standard_Real minRange = 0. , maxRange = 100. ;
3110
3111 Standard_Integer numIntervals = 10 ;
208e6839 3112 Standard_Integer textHeight = 16;
7fd59977 3113 Aspect_TypeOfColorScalePosition position = Aspect_TOCSP_RIGHT;
3114 Standard_Real X = 0., Y = 0. ;
3115
3116 if ( argc < 9 )
3117 {
3118 if( argc > 3 )
3119 {
91322f44 3120 minRange = Draw::Atof( argv[1] );
3121 maxRange = Draw::Atof( argv[2] );
3122 numIntervals = Draw::Atoi( argv[3] );
7fd59977 3123 }
3124 if ( argc > 4 )
91322f44 3125 textHeight = Draw::Atoi( argv[4] );
7fd59977 3126 if ( argc > 5 )
91322f44 3127 position = (Aspect_TypeOfColorScalePosition)Draw::Atoi( argv[5] );
7fd59977 3128 if ( argc > 7 )
3129 {
91322f44 3130 X = Draw::Atof( argv[6] );
3131 Y = Draw::Atof( argv[7] );
7fd59977 3132 }
3133 }
3134 Handle(V3d_View) curView = ViewerTest::CurrentView( );
3135 if ( curView.IsNull( ) )
3136 return 1;
3137 Handle(Aspect_ColorScale) aCSV = curView->ColorScale( );
3138 Handle(V3d_ColorScale) aCS = ( Handle( V3d_ColorScale )::DownCast( aCSV ) );
3139 if( ! aCS.IsNull( ) )
3140 {
3141 aCS->SetPosition( X , Y );
3142 aCS->SetHeight( 0.95) ;
3143 aCS->SetTextHeight( textHeight );
3144 aCS->SetRange( minRange , maxRange );
3145 aCS->SetNumberOfIntervals( numIntervals );
3146 aCS->SetLabelPosition( position );
3147 if( !curView->ColorScaleIsDisplayed() )
3148 curView->ColorScaleDisplay( );
3149 }
3150 return 0;
3151}
3152
3153//==============================================================================
3154//function : VGraduatedTrihedron
3155//purpose : Displays a graduated trihedron
3156//==============================================================================
13a22457
S		 3157
3158static void AddMultibyteString (TCollection_ExtendedString &name, const char *arg)
3159{
3160 const char *str = arg;
3161 while (*str)
3162 {
3163 unsigned short c1 = *str++;
3164 unsigned short c2 = *str++;
3165 if (!c1 || !c2) break;
3166 name += (Standard_ExtCharacter)((c1 << 8) | c2);
3167 }
3168}
3169
7fd59977 3170static int VGraduatedTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3171{
13a22457
S		 3172 // Check arguments
3173 if (argc != 2 && argc < 5)
3174 {
3175 di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
3176 di<<"Usage: type help "<<argv[0]<<"\n";
3177 return 1; //TCL_ERROR
3178 }
7fd59977 3179
13a22457
S		 3180 Handle(V3d_View) aV3dView = ViewerTest::CurrentView();
3181
3182 // Create 3D view if it doesn't exist
3183 if ( aV3dView.IsNull() )
7fd59977 3184 {
4fe56619 3185 ViewerTest::ViewerInit();
13a22457
S		 3186 aV3dView = ViewerTest::CurrentView();
3187 if( aV3dView.IsNull() )
3188 {
3189 di << "Error: Cannot create a 3D view\n";
3190 return 1; //TCL_ERROR
3191 }
7fd59977 3192 }
3193
13a22457 3194 // Erase (==0) or display (!=0)
91322f44 3195 const int display = Draw::Atoi(argv[1]);
7fd59977 3196
13a22457 3197 if (display)
7fd59977 3198 {
13a22457
S		 3199 // Text font
3200 TCollection_AsciiString font;
3201 if (argc < 6)
3202 font.AssignCat("Courier");
3203 else
3204 font.AssignCat(argv[5]);
3205
3206 // Text is multibyte
91322f44 3207 const Standard_Boolean isMultibyte = (argc < 7)? Standard_False : (Draw::Atoi(argv[6]) != 0);
13a22457
S		 3208
3209 // Set axis names
3210 TCollection_ExtendedString xname, yname, zname;
3211 if (argc >= 5)
3212 {
3213 if (isMultibyte)
7fd59977 3214 {
13a22457
S		 3215 AddMultibyteString(xname, argv[2]);
3216 AddMultibyteString(yname, argv[3]);
3217 AddMultibyteString(zname, argv[4]);
7fd59977 3218 }
13a22457
S		 3219 else
3220 {
3221 xname += argv[2];
3222 yname += argv[3];
3223 zname += argv[4];
3224 }
3225 }
3226 else
3227 {
3228 xname += "X (mm)";
3229 yname += "Y (mm)";
3230 zname += "Z (mm)";
3231 }
7fd59977 3232
13a22457
S		 3233 aV3dView->GraduatedTrihedronDisplay(xname, yname, zname,
3234 Standard_True/*xdrawname*/, Standard_True/*ydrawname*/, Standard_True/*zdrawname*/,
3235 Standard_True/*xdrawvalues*/, Standard_True/*ydrawvalues*/, Standard_True/*zdrawvalues*/,
3236 Standard_True/*drawgrid*/,
3237 Standard_True/*drawaxes*/,
3238 5/*nbx*/, 5/*nby*/, 5/*nbz*/,
3239 10/*xoffset*/, 10/*yoffset*/, 10/*zoffset*/,
3240 30/*xaxisoffset*/, 30/*yaxisoffset*/, 30/*zaxisoffset*/,
3241 Standard_True/*xdrawtickmarks*/, Standard_True/*ydrawtickmarks*/, Standard_True/*zdrawtickmarks*/,
3242 10/*xtickmarklength*/, 10/*ytickmarklength*/, 10/*ztickmarklength*/,
3243 Quantity_NOC_WHITE/*gridcolor*/,
3244 Quantity_NOC_RED/*xnamecolor*/,Quantity_NOC_GREEN/*ynamecolor*/,Quantity_NOC_BLUE1/*znamecolor*/,
3245 Quantity_NOC_RED/*xcolor*/,Quantity_NOC_GREEN/*ycolor*/,Quantity_NOC_BLUE1/*zcolor*/,font);
3246 }
7fd59977 3247 else
13a22457 3248 aV3dView->GraduatedTrihedronErase();
7fd59977 3249
3250 ViewerTest::GetAISContext()->UpdateCurrentViewer();
13a22457
S		 3251 aV3dView->Redraw();
3252
7fd59977 3253 return 0;
3254}
3255
7edf74fd
A		 3256//==============================================================================
3257//function : VPrintView
3258//purpose : Test printing algorithm, print the view to image file with given
3259// width and height. Printing implemented only for WNT.
3260//==============================================================================
4fe56619 3261static int VPrintView (Draw_Interpretor& di, Standard_Integer argc,
7edf74fd
A		 3262 const char** argv)
3263{
3264#ifndef WNT
3265 di << "Printing implemented only for wnt!\n";
b5ac8292 3266 return 0;
7edf74fd
A		 3267#else
3268
3269 Handle(AIS_InteractiveContext) aContextAIS = NULL;
3270 Handle(V3d_View) aView = NULL;
3271 aContextAIS = ViewerTest::GetAISContext();
3272 if (!aContextAIS.IsNull())
3273 {
3274 const Handle(V3d_Viewer)& Vwr = aContextAIS->CurrentViewer();
3275 Vwr->InitActiveViews();
3276 if(Vwr->MoreActiveViews())
3277 aView = Vwr->ActiveView();
3278 }
3279
3280 // check for errors
3281 if (aView.IsNull())
3282 {
3283 di << "Call vinit before!\n";
3284 return 1;
3285 }
3286 else if (argc < 4)
3287 {
3288 di << "Use: " << argv[0];
b5ac8292 3289 di << " width height filename [print algo=0] [tile_width tile_height]\n";
7edf74fd
A		 3290 di << "width, height of the intermediate buffer for operation\n";
3291 di << "algo : {0|1}\n";
3292 di << " 0 - stretch algorithm\n";
3293 di << " 1 - tile algorithm\n";
3294 di << "test printing algorithms into an intermediate buffer\n";
b5ac8292 3295 di << "using specific tile size if provided\n";
7edf74fd
A		 3296 di << "with saving output to an image file\n";
3297 return 1;
3298 }
3299
3300 // get the input params
91322f44 3301 Standard_Integer aWidth = Draw::Atoi (argv[1]);
3302 Standard_Integer aHeight = Draw::Atoi (argv[2]);
7edf74fd
A		 3303 Standard_Integer aMode = 0;
3304 TCollection_AsciiString aFileName = TCollection_AsciiString (argv[3]);
b5ac8292 3305 if (argc >= 5)
91322f44 3306 aMode = Draw::Atoi (argv[4]);
7edf74fd 3307
b5ac8292 3308 Standard_Integer aTileWidth = 0;
3309 Standard_Integer aTileHeight = 0;
3310 Standard_Boolean isTileSizeProvided = Standard_False;
3311 if (argc == 7)
3312 {
3313 isTileSizeProvided = Standard_True;
3314 aTileWidth = Draw::Atoi (argv[5]);
3315 aTileHeight = Draw::Atoi (argv[6]);
3316 }
3317
7edf74fd
A		 3318 // check the input parameters
3319 if (aWidth <= 0 || aHeight <= 0)
3320 {
3321 di << "Width and height must be positive values!\n";
3322 return 1;
3323 }
3324 if (aMode != 0 && aMode != 1)
3325 aMode = 0;
3326
7edf74fd 3327 // define compatible bitmap
692613e5 3328 HDC anDC = CreateCompatibleDC(0);
7edf74fd
A		 3329 BITMAPINFO aBitmapData;
3330 memset (&aBitmapData, 0, sizeof (BITMAPINFOHEADER));
3331 aBitmapData.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
3332 aBitmapData.bmiHeader.biWidth = aWidth ;
3333 aBitmapData.bmiHeader.biHeight = aHeight;
3334 aBitmapData.bmiHeader.biPlanes = 1;
3335 aBitmapData.bmiHeader.biBitCount = 24;
3336 aBitmapData.bmiHeader.biXPelsPerMeter = 0;
3337 aBitmapData.bmiHeader.biYPelsPerMeter = 0;
3338 aBitmapData.bmiHeader.biClrUsed = 0;
3339 aBitmapData.bmiHeader.biClrImportant = 0;
3340 aBitmapData.bmiHeader.biCompression = BI_RGB;
3341 aBitmapData.bmiHeader.biSizeImage = 0;
3342
3343 // Create Device Independent Bitmap
692613e5 3344 void* aBitsOut = NULL;
7edf74fd 3345 HBITMAP aMemoryBitmap = CreateDIBSection (anDC, &aBitmapData, DIB_RGB_COLORS,
692613e5 3346 &aBitsOut, NULL, 0);
7edf74fd
A		 3347 HGDIOBJ anOldBitmap = SelectObject(anDC, aMemoryBitmap);
3348
3349 Standard_Boolean isSaved = Standard_False, isPrinted = Standard_False;
692613e5 3350 if (aBitsOut != NULL)
4fe56619 3351 {
7edf74fd
A		 3352 if (aMode == 0)
3353 isPrinted = aView->Print(anDC,1,1,0,Aspect_PA_STRETCH);
3354 else
b5ac8292 3355 {
3356 if (isTileSizeProvided)
3357 {
3358 Graphic3d_CView* aCView = static_cast<Graphic3d_CView*> (ViewerTest::CurrentView()->View()->CView());
3359 Graphic3d_PtrFrameBuffer anOldBuffer = static_cast<Graphic3d_PtrFrameBuffer> (aCView->ptrFBO);
3360 aCView->ptrFBO = aView->View()->FBOCreate (aTileWidth, aTileHeight);
3361
3362 isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
3363
3364 Graphic3d_PtrFrameBuffer aNewBuffer = static_cast<Graphic3d_PtrFrameBuffer> (aCView->ptrFBO);
3365 aView->View()->FBORelease (aNewBuffer);
3366 aCView->ptrFBO = anOldBuffer;
3367 }
3368 else
3369 {
3370 isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
3371 }
3372 }
7edf74fd
A		 3373
3374 // succesfully printed into an intermediate buffer
3375 if (isPrinted)
3376 {
692613e5 3377 Image_PixMap aWrapper;
3378 aWrapper.InitWrapper (Image_PixMap::ImgBGR, (Standard_Byte* )aBitsOut, aWidth, aHeight, aWidth * 3 + aWidth % 4);
3379 aWrapper.SetTopDown (false);
3380
3381 Image_AlienPixMap anImageBitmap;
3382 anImageBitmap.InitCopy (aWrapper);
3383 isSaved = anImageBitmap.Save (aFileName);
7edf74fd
A		 3384 }
3385 else
3386 {
3387 di << "Print operation failed due to printing errors or\n";
3388 di << "insufficient memory available\n";
3389 di << "Please, try to use smaller dimensions for this test\n";
3390 di << "command, as it allocates intermediate buffer for storing\n";
3391 di << "the result\n";
3392 }
3393 }
3394 else
3395 {
3396 di << "Can't allocate memory for intermediate buffer\n";
3397 di << "Please use smaller dimensions\n";
3398 }
3399
3400 if (aMemoryBitmap)
3401 {
3402 SelectObject (anDC, anOldBitmap);
3403 DeleteObject (aMemoryBitmap);
3404 DeleteDC(anDC);
3405 }
3406
3407 if (!isSaved)
3408 {
3409 di << "Save to file operation failed. This operation may fail\n";
3410 di << "if you don't have enough available memory, then you can\n";
3411 di << "use smaller dimensions for the output file\n";
3412 return 1;
3413 }
3414
3415 return 0;
3416
3417#endif
3418}
3419
59f45b7c 3420//==============================================================================
3421//function : VZLayer
3422//purpose : Test z layer operations for v3d viewer
3423//==============================================================================
3424static int VZLayer (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3425{
3426 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext ();
3427 if (aContextAIS.IsNull())
3428 {
3429 di << "Call vinit before!\n";
3430 return 1;
3431 }
3432 else if (argc < 2)
3433 {
c5751993 3434 di << "Use: vzlayer ";
3435 di << " add/del/get/settings/enable/disable [id]\n";
59f45b7c 3436 di << " add - add new z layer to viewer and print its id\n";
3437 di << " del - del z layer by its id\n";
3438 di << " get - print sequence of z layers in increasing order of their overlay level\n";
c5751993 3439 di << " settings - print status of z layer settings\n";
3440 di << " enable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n enables given setting for the z layer\n";
3441 di << " enable (p[ositive]offset/n[egative]offset) \n enables given setting for the z layer\n";
3442 di << " disable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n disables given setting for the z layer\n";
3443 di << "\nWhere id is the layer identificator\n";
3444 di << "\nExamples:\n";
3445 di << " vzlayer add\n";
3446 di << " vzlayer enable poffset 1\n";
3447 di << " vzlayer disable depthtest 1\n";
3448 di << " vzlayer del 1\n";
59f45b7c 3449 return 1;
3450 }
3451
3452 const Handle(V3d_Viewer)& aViewer = aContextAIS->CurrentViewer();
3453 if (aViewer.IsNull())
3454 {
3455 di << "No active viewer!\n";
3456 return 1;
3457 }
3458
3459 // perform operation
3460 TCollection_AsciiString anOp = TCollection_AsciiString (argv[1]);
3461 if (anOp == "add")
3462 {
3463 Standard_Integer aNewId;
3464 if (!aViewer->AddZLayer (aNewId))
3465 {
3466 di << "Impossible to add new z layer!\n";
3467 return 1;
3468 }
3469
3470 di << "New z layer added with index: " << aNewId << "\n";
3471 }
3472 else if (anOp == "del")
3473 {
3474 if (argc < 3)
3475 {
3476 di << "Please also provide as argument id of z layer to remove\n";
3477 return 1;
3478 }
3479
91322f44 3480 Standard_Integer aDelId = Draw::Atoi (argv[2]);
59f45b7c 3481 if (!aViewer->RemoveZLayer (aDelId))
3482 {
3483 di << "Impossible to remove the z layer or invalid id!\n";
3484 return 1;
3485 }
3486
3487 di << "Z layer " << aDelId << " has been removed\n";
3488 }
3489 else if (anOp == "get")
3490 {
3491 TColStd_SequenceOfInteger anIds;
3492 aViewer->GetAllZLayers (anIds);
3493 for (Standard_Integer aSeqIdx = 1; aSeqIdx <= anIds.Length(); aSeqIdx++)
3494 {
3495 di << anIds.Value (aSeqIdx) << " ";
3496 }
3497
3498 di << "\n";
3499 }
c5751993 3500 else if (anOp == "settings")
3501 {
3502 if (argc < 3)
3503 {
3504 di << "Please also provide an id\n";
3505 return 1;
3506 }
3507
3508 Standard_Integer anId = Draw::Atoi (argv[2]);
3509 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
3510
3511 di << "Depth test - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthTest) ? "enabled" : "disabled") << "\n";
3512 di << "Depth write - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthWrite) ? "enabled" : "disabled") << "\n";
3513 di << "Depth buffer clearing - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthClear) ? "enabled" : "disabled") << "\n";
3514 di << "Depth offset - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthOffset) ? "enabled" : "disabled") << "\n";
3515
3516 }
3517 else if (anOp == "enable")
3518 {
3519 if (argc < 3)
3520 {
3521 di << "Please also provide an option to enable\n";
3522 return 1;
3523 }
3524
3525 if (argc < 4)
3526 {
3527 di << "Please also provide a layer id\n";
3528 return 1;
3529 }
3530
3531 TCollection_AsciiString aSubOp = TCollection_AsciiString (argv[2]);
3532 Standard_Integer anId = Draw::Atoi (argv[3]);
3533 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
3534
3535 if (aSubOp == "depthtest" || aSubOp == "test")
3536 {
3537 aSettings.EnableSetting (Graphic3d_ZLayerDepthTest);
3538 }
3539 else if (aSubOp == "depthwrite" || aSubOp == "write")
3540 {
3541 aSettings.EnableSetting (Graphic3d_ZLayerDepthWrite);
3542 }
3543 else if (aSubOp == "depthclear" || aSubOp == "clear")
3544 {
3545 aSettings.EnableSetting (Graphic3d_ZLayerDepthClear);
3546 }
3547 else if (aSubOp == "depthoffset" || aSubOp == "offset")
3548 {
3549 if (argc < 6)
3550 {
3551 di << "Please also provide a factor and units values for depth offset\n";
3552 di << "Format is: vzlayer enable offset [factor] [units] [layerId]\n";
3553 return 1;
3554 }
3555
3556 Standard_ShortReal aFactor = static_cast<Standard_ShortReal> (Draw::Atof (argv[3]));
3557 Standard_ShortReal aUnits = static_cast<Standard_ShortReal> (Draw::Atof (argv[4]));
3558 anId = Draw::Atoi (argv[5]);
3559 aSettings = aViewer->ZLayerSettings (anId);
3560
3561 aSettings.DepthOffsetFactor = aFactor;
3562 aSettings.DepthOffsetUnits = aUnits;
3563
3564 aSettings.EnableSetting (Graphic3d_ZLayerDepthOffset);
3565 }
3566 else if (aSubOp == "positiveoffset" || aSubOp == "poffset")
3567 {
3568 aSettings.SetDepthOffsetPositive();
3569 }
3570 else if (aSubOp == "negativeoffset" || aSubOp == "noffset")
3571 {
3572 aSettings.SetDepthOffsetNegative();
3573 }
3574
3575 aViewer->SetZLayerSettings (anId, aSettings);
3576 }
3577 else if (anOp == "disable")
3578 {
3579 if (argc < 3)
3580 {
3581 di << "Please also provide an option to disable\n";
3582 return 1;
3583 }
3584
3585 if (argc < 4)
3586 {
3587 di << "Please also provide a layer id\n";
3588 return 1;
3589 }
3590
3591 TCollection_AsciiString aSubOp = TCollection_AsciiString (argv[2]);
3592 Standard_Integer anId = Draw::Atoi (argv[3]);
3593 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
3594
3595 if (aSubOp == "depthtest" || aSubOp == "test")
3596 {
3597 aSettings.DisableSetting (Graphic3d_ZLayerDepthTest);
3598 }
3599 else if (aSubOp == "depthwrite" || aSubOp == "write")
3600 {
3601 aSettings.DisableSetting (Graphic3d_ZLayerDepthWrite);
3602 }
3603 else if (aSubOp == "depthclear" || aSubOp == "clear")
3604 {
3605 aSettings.DisableSetting (Graphic3d_ZLayerDepthClear);
3606 }
3607 else if (aSubOp == "depthoffset" || aSubOp == "offset")
3608 {
3609 aSettings.DisableSetting (Graphic3d_ZLayerDepthOffset);
3610 }
3611
3612 aViewer->SetZLayerSettings (anId, aSettings);
3613 }
59f45b7c 3614 else
3615 {
c5751993 3616 di << "Invalid operation, please use { add / del / get / settings / enable / disable}\n";
59f45b7c 3617 return 1;
3618 }
3619
3620 return 0;
3621}
3622
25289ec1 3623DEFINE_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
3624
3625// this class provides a presentation of text item in v3d view under-/overlayer
3626class V3d_TextItem : public Visual3d_LayerItem
3627{
3628public:
3629
3630 // CASCADE RTTI
3631 DEFINE_STANDARD_RTTI(V3d_TextItem)
3632
3633 // constructor
3634 Standard_EXPORT V3d_TextItem(const TCollection_AsciiString& theText,
3635 const Standard_Real theX1,
3636 const Standard_Real theY1,
3637 const Standard_Real theHeight,
3638 const TCollection_AsciiString& theFontName,
3639 const Quantity_Color& theColor,
3640 const Quantity_Color& theSubtitleColor,
3641 const Aspect_TypeOfDisplayText& theTypeOfDisplay,
3642 const Handle(Visual3d_Layer)& theLayer);
3643
3644 // redraw method
3645 Standard_EXPORT void RedrawLayerPrs();
3646
3647private:
3648
3649 Standard_Real myX1;
3650 Standard_Real myY1;
25289ec1 3651 TCollection_AsciiString myText;
eafb234b 3652 Standard_Real myHeight;
3653 Handle(Visual3d_Layer) myLayer;
25289ec1 3654 Quantity_Color myColor;
3655 Quantity_Color mySubtitleColor;
3656 Aspect_TypeOfDisplayText myType;
eafb234b 3657 TCollection_AsciiString myFontName;
25289ec1 3658};
3659
3660IMPLEMENT_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
3661IMPLEMENT_STANDARD_RTTIEXT(V3d_TextItem, Visual3d_LayerItem)
3662
3663// create and add to display the text item
3664V3d_TextItem::V3d_TextItem (const TCollection_AsciiString& theText,
3665 const Standard_Real theX1,
3666 const Standard_Real theY1,
3667 const Standard_Real theHeight,
3668 const TCollection_AsciiString& theFontName,
3669 const Quantity_Color& theColor,
3670 const Quantity_Color& theSubtitleColor,
3671 const Aspect_TypeOfDisplayText& theTypeOfDisplay,
3672 const Handle(Visual3d_Layer)& theLayer)
3673 : myX1 (theX1), myY1 (theY1),
3674 myText (theText),
3675 myHeight (theHeight),
3676 myLayer (theLayer),
3677 myColor (theColor),
3678 mySubtitleColor (theSubtitleColor),
3679 myType (theTypeOfDisplay),
3680 myFontName (theFontName)
3681{
3682 if (!myLayer.IsNull ())
3683 myLayer->AddLayerItem (this);
3684}
3685
3686// render item
3687void V3d_TextItem::RedrawLayerPrs ()
4fe56619 3688{
25289ec1 3689 if (myLayer.IsNull ())
3690 return;
3691
3692 myLayer->SetColor (myColor);
3693 myLayer->SetTextAttributes (myFontName.ToCString (), myType, mySubtitleColor);
3694 myLayer->DrawText (myText.ToCString (), myX1, myY1, myHeight);
3695}
3696
20637bd2 3697DEFINE_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
3698
3699// The Visual3d_LayerItem line item for "vlayerline" command
4fe56619 3700// it provides a presentation of line with user-defined
20637bd2 3701// linewidth, linetype and transparency.
4fe56619 3702class V3d_LineItem : public Visual3d_LayerItem
20637bd2 3703{
3704public:
3705 // CASCADE RTTI
4fe56619 3706 DEFINE_STANDARD_RTTI(V3d_LineItem)
3707
20637bd2 3708 // constructor
3709 Standard_EXPORT V3d_LineItem(Standard_Real X1, Standard_Real Y1,
3710 Standard_Real X2, Standard_Real Y2,
3711 V3d_LayerMgrPointer theLayerMgr,
3712 Aspect_TypeOfLine theType = Aspect_TOL_SOLID,
3713 Standard_Real theWidth = 0.5,
3714 Standard_Real theTransp = 1.0);
3715
3716 // redraw method
3717 Standard_EXPORT void RedrawLayerPrs();
3718
3719private:
3720
3721 Standard_Real myX1, myY1, myX2, myY2;
eafb234b 3722 V3d_LayerMgrPointer myLayerMgr;
3723 Aspect_TypeOfLine myType;
20637bd2 3724 Standard_Real myWidth;
3725 Standard_Real myTransparency;
20637bd2 3726};
3727
3728IMPLEMENT_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
3729IMPLEMENT_STANDARD_RTTIEXT(V3d_LineItem, Visual3d_LayerItem)
3730
3731// default constructor for line item
4fe56619 3732V3d_LineItem::V3d_LineItem(Standard_Real X1, Standard_Real Y1,
20637bd2 3733 Standard_Real X2, Standard_Real Y2,
3734 V3d_LayerMgrPointer theLayerMgr,
3735 Aspect_TypeOfLine theType,
3736 Standard_Real theWidth,
3737 Standard_Real theTransp) :
3738 myX1(X1), myY1(Y1), myX2(X2), myY2(Y2), myLayerMgr(theLayerMgr),
3739 myType(theType), myWidth(theWidth), myTransparency(theTransp)
3740{
9e4c2fbb 3741 if (myLayerMgr && !myLayerMgr->Overlay().IsNull())
20637bd2 3742 myLayerMgr->Overlay()->AddLayerItem (this);
3743}
3744
3745// render line
3746void V3d_LineItem::RedrawLayerPrs ()
3747{
3748 Handle (Visual3d_Layer) aOverlay;
4fe56619 3749
20637bd2 3750 if (myLayerMgr)
3751 aOverlay = myLayerMgr->Overlay();
3752
3753 if (!aOverlay.IsNull())
3754 {
3755 Quantity_Color aColor(1.0, 0, 0, Quantity_TOC_RGB);
3756 aOverlay->SetColor(aColor);
3757 aOverlay->SetTransparency((Standard_ShortReal)myTransparency);
3758 aOverlay->SetLineAttributes((Aspect_TypeOfLine)myType, myWidth);
3759 aOverlay->BeginPolyline();
3760 aOverlay->AddVertex(myX1, myY1);
3761 aOverlay->AddVertex(myX2, myY2);
3762 aOverlay->ClosePrimitive();
3763 }
3764}
3765
3766//=============================================================================
3767//function : VLayerLine
3768//purpose : Draws line in the v3d view layer with given attributes: linetype,
3769// : linewidth, transparency coefficient
3770//============================================================================
3771static int VLayerLine(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3772{
3773 // get the active view
3774 Handle(V3d_View) aView = ViewerTest::CurrentView();
3775 if (aView.IsNull())
3776 {
3777 di << "Call vinit before!\n";
3778 return 1;
3779 }
3780 else if (argc < 5)
3781 {
3782 di << "Use: " << argv[0];
3783 di << " x1 y1 x2 y2 [linewidth = 0.5] [linetype = 0] [transparency = 1]\n";
3784 di << " linetype : { 0 | 1 | 2 | 3 } \n";
3785 di << " 0 - solid \n";
3786 di << " 1 - dashed \n";
3787 di << " 2 - dot \n";
3788 di << " 3 - dashdot\n";
3789 di << " transparency : { 0.0 - 1.0 } \n";
3790 di << " 0.0 - transparent\n";
3791 di << " 1.0 - visible \n";
3792 return 1;
3793 }
3794
3795 // get the input params
91322f44 3796 Standard_Real X1 = Draw::Atof(argv[1]);
3797 Standard_Real Y1 = Draw::Atof(argv[2]);
3798 Standard_Real X2 = Draw::Atof(argv[3]);
3799 Standard_Real Y2 = Draw::Atof(argv[4]);
20637bd2 3800
3801 Standard_Real aWidth = 0.5;
3802 Standard_Integer aType = 0;
3803 Standard_Real aTransparency = 1.0;
3804
3805 // has width
3806 if (argc > 5)
91322f44 3807 aWidth = Draw::Atof(argv[5]);
20637bd2 3808
3809 // has type
3810 if (argc > 6)
91322f44 3811 aType = (Standard_Integer) Draw::Atoi(argv[6]);
20637bd2 3812
3813 // has transparency
3814 if (argc > 7)
3815 {
91322f44 3816 aTransparency = Draw::Atof(argv[7]);
4fe56619 3817 if (aTransparency < 0 || aTransparency > 1.0)
20637bd2 3818 aTransparency = 1.0;
3819 }
3820
3821 // select appropriate line type
3822 Aspect_TypeOfLine aLineType;
3823 switch (aType)
3824 {
3825 case 1:
3826 aLineType = Aspect_TOL_DASH;
3827 break;
3828
3829 case 2:
3830 aLineType = Aspect_TOL_DOT;
3831 break;
3832
3833 case 3:
3834 aLineType = Aspect_TOL_DOTDASH;
3835 break;
3836
3837 default:
3838 aLineType = Aspect_TOL_SOLID;
3839 }
3840
3841 // replace layer manager
3842 Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr(aView);
3843 aView->SetLayerMgr(aMgr);
3844
3845 // add line item
4fe56619 3846 Handle (V3d_LineItem) anItem = new V3d_LineItem(X1, Y1, X2, Y2,
20637bd2 3847 aMgr.operator->(),
4fe56619 3848 aLineType, aWidth,
20637bd2 3849 aTransparency);
3850
3851 // update view
3852 aView->MustBeResized();
3853 aView->Redraw();
3854
3855 return 0;
3856}
3857
25289ec1 3858//=======================================================================
3859//function : VOverlayText
3860//purpose : Test text displaying in view overlay
3861//=======================================================================
3862static int VOverlayText (Draw_Interpretor& di, Standard_Integer argc, const char**argv)
3863{
3864 // get the active view
3865 Handle(V3d_View) aView = ViewerTest::CurrentView();
3866 if (aView.IsNull())
3867 {
3868 di << "No active view. Please call vinit.\n";
3869 return 1;
3870 }
3871 else if (argc < 4 || argc > 13)
3872 {
3873 di << "Use: " << argv[0];
3874 di << " text x y [height] [font_name] [text_color: R G B] [displayType]\n";
3875 di << "[background_color: R G B]\n";
3876 di << " height - pixel height of the text (default=10.0)\n";
3877 di << " font_name - name of font (default=courier)\n";
3878 di << " text_color - R G B values of text color (default=255.0 255.0 255.0)\n";
a6eb515f 3879 di << " display_type = {normal/subtitle/decal/blend/dimension}, (default=normal)\n";
25289ec1 3880 di << " background_color- R G B values used for subtitle and decal text\n";
3881 di << "(default=255.0 255.0 255.0)\n";
3882 return 1;
3883 }
4fe56619 3884
25289ec1 3885 TCollection_AsciiString aText (argv[1]);
91322f44 3886 Standard_Real aPosX = Draw::Atof(argv[2]);
3887 Standard_Real aPosY = Draw::Atof(argv[3]);
3888 Standard_Real aHeight = (argc >= 5) ? Draw::Atof (argv[4]) : 10.0;
25289ec1 3889
3890 // font name
3891 TCollection_AsciiString aFontName = "Courier";
3892 if (argc >= 6)
3893 aFontName = TCollection_AsciiString (argv[5]);
3894
3895 // text colors
3896 Quantity_Parameter aColorRed = 1.0;
3897 Quantity_Parameter aColorGreen = 1.0;
3898 Quantity_Parameter aColorBlue = 1.0;
3899 if (argc >= 9)
3900 {
91322f44 3901 aColorRed = Draw::Atof (argv[6])/255.;
3902 aColorGreen = Draw::Atof (argv[7])/255.;
3903 aColorBlue = Draw::Atof (argv[8])/255.;
25289ec1 3904 }
3905
3906 // display type
3907 TCollection_AsciiString aDispStr;
3908 if (argc >= 10)
3909 aDispStr = TCollection_AsciiString (argv[9]);
3910
3911 Aspect_TypeOfDisplayText aTextType = Aspect_TODT_NORMAL;
3912 if (aDispStr.IsEqual ("subtitle"))
3913 aTextType = Aspect_TODT_SUBTITLE;
3914 else if (aDispStr.IsEqual ("decal"))
3915 aTextType = Aspect_TODT_DEKALE;
3916 else if (aDispStr.IsEqual ("blend"))
3917 aTextType = Aspect_TODT_BLEND;
a6eb515f 3918 else if (aDispStr.IsEqual ("dimension"))
3919 aTextType = Aspect_TODT_DIMENSION;
25289ec1 3920
3921 // subtitle color
3922 Quantity_Parameter aSubRed = 1.0;
3923 Quantity_Parameter aSubGreen = 1.0;
3924 Quantity_Parameter aSubBlue = 1.0;
3925 if (argc == 13)
3926 {
91322f44 3927 aSubRed = Draw::Atof (argv[10])/255.;
3928 aSubGreen = Draw::Atof (argv[11])/255.;
3929 aSubBlue = Draw::Atof (argv[12])/255.;
25289ec1 3930 }
3931
3932 // check fo current overlay
3933 Handle(Visual3d_Layer) anOverlay = aView->Viewer()->Viewer()->OverLayer ();
3934 if (anOverlay.IsNull ())
3935 {
3936 Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr (aView);
3937 anOverlay = aMgr->Overlay ();
3938 aView->SetLayerMgr (aMgr);
3939 }
3940
4fe56619 3941 Quantity_Color aTextColor (aColorRed, aColorGreen,
25289ec1 3942 aColorBlue, Quantity_TOC_RGB);
4fe56619 3943 Quantity_Color aSubtColor (aSubRed, aSubGreen,
25289ec1 3944 aSubBlue, Quantity_TOC_RGB);
3945
3946 // add text item
3947 Handle(V3d_TextItem) anItem = new V3d_TextItem (aText, aPosX, aPosY,
3948 aHeight, aFontName, aTextColor, aSubtColor, aTextType, anOverlay);
3949
3950 // update view
3951 aView->MustBeResized();
3952 aView->Redraw();
3953
3954 return 0;
3955}
3956
2bd4c032 3957//==============================================================================
3958//function : VGrid
3959//purpose :
3960//==============================================================================
3961
35e08fe8 3962static int VGrid (Draw_Interpretor& /*theDI*/,
2bd4c032 3963 Standard_Integer theArgNb,
3964 const char** theArgVec)
3965{
3966 // get the active view
3967 Handle(V3d_View) aView = ViewerTest::CurrentView();
3968 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
3969 if (aView.IsNull() || aViewer.IsNull())
3970 {
3971 std::cerr << "No active view. Please call vinit.\n";
3972 return 1;
3973 }
3974
3975 Aspect_GridType aType = aViewer->GridType();
3976 Aspect_GridDrawMode aMode = aViewer->GridDrawMode();
3977
3978 Standard_Integer anIter = 1;
3979 for (; anIter < theArgNb; ++anIter)
3980 {
3981 const char* aValue = theArgVec[anIter];
3982 if (*aValue == 'r')
3983 {
3984 aType = Aspect_GT_Rectangular;
3985 }
3986 else if (*aValue == 'c')
3987 {
3988 aType = Aspect_GT_Circular;
3989 }
3990 else if (*aValue == 'l')
3991 {
3992 aMode = Aspect_GDM_Lines;
3993 }
3994 else if (*aValue == 'p')
3995 {
3996 aMode = Aspect_GDM_Points;
3997 }
3998 else if (strcmp (aValue, "off" ) == 0)
3999 {
4000 aViewer->DeactivateGrid();
4001 return 0;
4002 }
4003 else
4004 {
4005 break;
4006 }
4007 }
4008
4009 Standard_Integer aTail = (theArgNb - anIter);
4010 if (aTail == 0)
4011 {
4012 aViewer->ActivateGrid (aType, aMode);
4013 return 0;
4014 }
4015 else if (aTail != 2 && aTail != 5)
4016 {
4017 std::cerr << "Incorrect arguments number! Usage:\n"
4018 << "vgrid [off] [Mode={r|c}] [Type={l|p}] [OriginX OriginY [StepX/StepRadius StepY/DivNb RotAngle]]\n";
4019 return 1;
4020 }
4021
4022 Quantity_Length anOriginX, anOriginY;
4023 Quantity_PlaneAngle aRotAngle;
4024 if (aType == Aspect_GT_Rectangular)
4025 {
4026 Quantity_Length aRStepX, aRStepY;
4027 aViewer->RectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
4028
91322f44 4029 anOriginX = Draw::Atof (theArgVec[anIter++]);
4030 anOriginY = Draw::Atof (theArgVec[anIter++]);
2bd4c032 4031 if (aTail == 5)
4032 {
91322f44 4033 aRStepX = Draw::Atof (theArgVec[anIter++]);
4034 aRStepY = Draw::Atof (theArgVec[anIter++]);
4035 aRotAngle = Draw::Atof (theArgVec[anIter++]);
2bd4c032 4036 }
4037 aViewer->SetRectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
4038 aViewer->ActivateGrid (aType, aMode);
4039 }
4040 else if (aType == Aspect_GT_Circular)
4041 {
4042 Quantity_Length aRadiusStep;
4043 Standard_Integer aDivisionNumber;
4044 aViewer->CircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
4045
91322f44 4046 anOriginX = Draw::Atof (theArgVec[anIter++]);
4047 anOriginY = Draw::Atof (theArgVec[anIter++]);
2bd4c032 4048 if (aTail == 5)
4049 {
91322f44 4050 aRadiusStep = Draw::Atof (theArgVec[anIter++]);
4051 aDivisionNumber = Draw::Atoi (theArgVec[anIter++]);
4052 aRotAngle = Draw::Atof (theArgVec[anIter++]);
2bd4c032 4053 }
4054
4055 aViewer->SetCircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
4056 aViewer->ActivateGrid (aType, aMode);
4057 }
4058
4059 return 0;
4060}
4061
208e6839 4062//==============================================================================
4063//function : VFps
4064//purpose :
4065//==============================================================================
4066
4067static int VFps (Draw_Interpretor& theDI,
4068 Standard_Integer theArgNb,
4069 const char** theArgVec)
4070{
4071 // get the active view
4072 Handle(V3d_View) aView = ViewerTest::CurrentView();
4073 if (aView.IsNull())
4074 {
4075 std::cerr << "No active view. Please call vinit.\n";
4076 return 1;
4077 }
4078
91322f44 4079 Standard_Integer aFramesNb = (theArgNb > 1) ? Draw::Atoi(theArgVec[1]) : 100;
208e6839 4080 if (aFramesNb <= 0)
4081 {
4082 std::cerr << "Incorrect arguments!\n";
4083 return 1;
4084 }
4085
4086 // the time is meaningless for first call
4087 // due to async OpenGl rendering
4088 aView->Redraw();
4089
4090 // redraw view in loop to estimate average values
4091 OSD_Timer aTimer;
4092 aTimer.Start();
4093 for (Standard_Integer anInter = 0; anInter < aFramesNb; ++anInter)
4094 {
4095 aView->Redraw();
4096 }
4097 aTimer.Stop();
4098 Standard_Real aCpu;
4099 const Standard_Real aTime = aTimer.ElapsedTime();
4100 aTimer.OSD_Chronometer::Show (aCpu);
4101
4102 const Standard_Real aFpsAver = Standard_Real(aFramesNb) / aTime;
4103 const Standard_Real aCpuAver = aCpu / Standard_Real(aFramesNb);
4104
4105 // return statistics
4106 theDI << "FPS: " << aFpsAver << "\n"
4107 << "CPU: " << (1000.0 * aCpuAver) << " msec\n";
4108
4109 return 0;
4110}
4111
58655684 4112//==============================================================================
4113//function : VGlDebug
4114//purpose :
4115//==============================================================================
4116
4117static int VGlDebug (Draw_Interpretor& theDI,
4118 Standard_Integer theArgNb,
4119 const char** theArgVec)
4120{
aaf512f1 4121 Handle(OpenGl_GraphicDriver) aDriver;
4122 Handle(V3d_View) aView = ViewerTest::CurrentView();
4123 if (!aView.IsNull())
4124 {
4125 aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aView->Viewer()->Driver());
4126 }
58655684 4127 if (theArgNb < 2)
4128 {
aaf512f1 4129 if (aDriver.IsNull())
58655684 4130 {
4131 std::cerr << "No active view. Please call vinit.\n";
4132 return 0;
4133 }
4134
4135 Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )glGetString (GL_EXTENSIONS),
4136 "GL_ARB_debug_output");
4137 std::cout << "Active graphic driver: debug " << (isActive ? "ON" : "OFF") << "\n";
4138 theDI << (isActive ? "1" : "0");
4139 return 0;
4140 }
4141
aaf512f1 4142 const Standard_Boolean toEnableDebug = Draw::Atoi (theArgVec[1]) != 0;
4143 ViewerTest_myDefaultCaps.contextDebug = toEnableDebug;
4144 ViewerTest_myDefaultCaps.glslWarnings = toEnableDebug;
4145 if (aDriver.IsNull())
4146 {
4147 return 0;
4148 }
4149
4150 aDriver->ChangeOptions().glslWarnings = toEnableDebug;
58655684 4151 return 0;
4152}
208e6839 4153
4154//==============================================================================
4155//function : VVbo
4156//purpose :
4157//==============================================================================
4158
58655684 4159static int VVbo (Draw_Interpretor& theDI,
208e6839 4160 Standard_Integer theArgNb,
4161 const char** theArgVec)
4162{
58655684 4163 const Standard_Boolean toSet = (theArgNb > 1);
4164 const Standard_Boolean toUseVbo = toSet ? (Draw::Atoi (theArgVec[1]) == 0) : 1;
4165 if (toSet)
208e6839 4166 {
58655684 4167 ViewerTest_myDefaultCaps.vboDisable = toUseVbo;
208e6839 4168 }
4169
58655684 4170 // get the context
4171 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
4172 if (aContextAIS.IsNull())
208e6839 4173 {
58655684 4174 if (!toSet)
4175 {
4176 std::cerr << "No active view!\n";
4177 }
208e6839 4178 return 1;
4179 }
58655684 4180 Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
4181 if (!aDriver.IsNull())
208e6839 4182 {
58655684 4183 if (!toSet)
4184 {
4185 theDI << (aDriver->Options().vboDisable ? "0" : "1") << "\n";
4186 }
4187 else
4188 {
4189 aDriver->ChangeOptions().vboDisable = toUseVbo;
4190 }
208e6839 4191 }
4192
208e6839 4193 return 0;
4194}
4195
a577aaab 4196//==============================================================================
4197//function : VCaps
4198//purpose :
4199//==============================================================================
4200
4201static int VCaps (Draw_Interpretor& theDI,
4202 Standard_Integer theArgNb,
4203 const char** theArgVec)
4204{
4205 OpenGl_Caps* aCaps = &ViewerTest_myDefaultCaps;
4206 Handle(OpenGl_GraphicDriver) aDriver;
8625ef7e 4207 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4208 if (!aContext.IsNull())
a577aaab 4209 {
8625ef7e 4210 aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContext->CurrentViewer()->Driver());
a577aaab 4211 aCaps = &aDriver->ChangeOptions();
4212 }
4213
4214 if (theArgNb < 2)
4215 {
4216 theDI << "VBO: " << (aCaps->vboDisable ? "0" : "1") << "\n";
4217 theDI << "Sprites: " << (aCaps->pntSpritesDisable ? "0" : "1") << "\n";
abe46077 4218 theDI << "SoftMode:" << (aCaps->contextNoAccel ? "1" : "0") << "\n";
8625ef7e 4219 theDI << "FFP: " << (aCaps->ffpEnable ? "1" : "0") << "\n";
a577aaab 4220 return 0;
4221 }
4222
8625ef7e 4223 ViewerTest_AutoUpdater anUpdateTool (aContext, ViewerTest::CurrentView());
a577aaab 4224 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
4225 {
8625ef7e 4226 Standard_CString anArg = theArgVec[anArgIter];
4227 TCollection_AsciiString anArgCase (anArg);
4228 anArgCase.LowerCase();
4229 if (anUpdateTool.parseRedrawMode (anArg))
4230 {
4231 continue;
4232 }
4233 else if (anArgCase == "-ffp")
4234 {
4235 Standard_Boolean toEnable = Standard_True;
4236 if (++anArgIter < theArgNb
4237 && !parseOnOff (theArgVec[anArgIter], toEnable))
4238 {
4239 --anArgIter;
4240 }
4241 aCaps->ffpEnable = toEnable;
4242 }
4243 else if (anArgCase == "-vbo")
a577aaab 4244 {
8625ef7e 4245 Standard_Boolean toEnable = Standard_True;
4246 if (++anArgIter < theArgNb
4247 && !parseOnOff (theArgVec[anArgIter], toEnable))
4248 {
4249 --anArgIter;
4250 }
4251 aCaps->vboDisable = !toEnable;
a577aaab 4252 }
8625ef7e 4253 else if (anArgCase == "-sprite"
4254 || anArgCase == "-sprites")
a577aaab 4255 {
8625ef7e 4256 Standard_Boolean toEnable = Standard_True;
4257 if (++anArgIter < theArgNb
4258 && !parseOnOff (theArgVec[anArgIter], toEnable))
4259 {
4260 --anArgIter;
4261 }
4262 aCaps->pntSpritesDisable = !toEnable;
a577aaab 4263 }
8625ef7e 4264 else if (anArgCase == "-softmode")
abe46077 4265 {
8625ef7e 4266 Standard_Boolean toEnable = Standard_True;
4267 if (++anArgIter < theArgNb
4268 && !parseOnOff (theArgVec[anArgIter], toEnable))
4269 {
4270 --anArgIter;
4271 }
4272 aCaps->contextNoAccel = toEnable;
4273 }
4274 else if (anArgCase == "-accel"
4275 || anArgCase == "-acceleration")
4276 {
4277 Standard_Boolean toEnable = Standard_True;
4278 if (++anArgIter < theArgNb
4279 && !parseOnOff (theArgVec[anArgIter], toEnable))
4280 {
4281 --anArgIter;
4282 }
4283 aCaps->contextNoAccel = !toEnable;
abe46077 4284 }
a577aaab 4285 else
4286 {
8625ef7e 4287 std::cout << "Error: unknown argument '" << anArg << "'\n";
4288 return 1;
a577aaab 4289 }
4290 }
4291 if (aCaps != &ViewerTest_myDefaultCaps)
4292 {
4293 ViewerTest_myDefaultCaps = *aCaps;
4294 }
4295 return 0;
4296}
4297
f0430952 4298//==============================================================================
4299//function : VMemGpu
4300//purpose :
4301//==============================================================================
4302
4303static int VMemGpu (Draw_Interpretor& theDI,
4304 Standard_Integer theArgNb,
4305 const char** theArgVec)
4306{
4307 // get the context
4308 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
4309 if (aContextAIS.IsNull())
4310 {
4311 std::cerr << "No active view. Please call vinit.\n";
4312 return 1;
4313 }
4314
dc3fe572 4315 Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
f0430952 4316 if (aDriver.IsNull())
4317 {
4318 std::cerr << "Graphic driver not available.\n";
4319 return 1;
4320 }
4321
4322 Standard_Size aFreeBytes = 0;
4323 TCollection_AsciiString anInfo;
4324 if (!aDriver->MemoryInfo (aFreeBytes, anInfo))
4325 {
4326 std::cerr << "Information not available.\n";
4327 return 1;
4328 }
4329
4330 if (theArgNb > 1 && *theArgVec[1] == 'f')
4331 {
4332 theDI << Standard_Real (aFreeBytes);
4333 }
4334 else
4335 {
4336 theDI << anInfo;
4337 }
4338
4339 return 0;
4340}
4341
85e096c3 4342// ==============================================================================
4343// function : VReadPixel
4344// purpose :
4345// ==============================================================================
4346static int VReadPixel (Draw_Interpretor& theDI,
4347 Standard_Integer theArgNb,
4348 const char** theArgVec)
4349{
4350 // get the active view
4351 Handle(V3d_View) aView = ViewerTest::CurrentView();
4352 if (aView.IsNull())
4353 {
4354 std::cerr << "No active view. Please call vinit.\n";
4355 return 1;
4356 }
4357 else if (theArgNb < 3)
4358 {
4359 std::cerr << "Usage : " << theArgVec[0] << " xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]\n";
4360 return 1;
4361 }
4362
692613e5 4363 Image_PixMap::ImgFormat aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA;
4364 Graphic3d_BufferType aBufferType = Graphic3d_BT_RGBA;
4365
85e096c3 4366 Standard_Integer aWidth, aHeight;
4367 aView->Window()->Size (aWidth, aHeight);
91322f44 4368 const Standard_Integer anX = Draw::Atoi (theArgVec[1]);
4369 const Standard_Integer anY = Draw::Atoi (theArgVec[2]);
85e096c3 4370 if (anX < 0 || anX >= aWidth || anY < 0 || anY > aHeight)
4371 {
4372 std::cerr << "Pixel coordinates (" << anX << "; " << anY << ") are out of view (" << aWidth << " x " << aHeight << ")\n";
4373 return 1;
4374 }
4375
4376 Standard_Boolean toShowName = Standard_False;
4377 Standard_Boolean toShowHls = Standard_False;
4378 for (Standard_Integer anIter = 3; anIter < theArgNb; ++anIter)
4379 {
29cb310a 4380 const char* aParam = theArgVec[anIter];
4381 if ( strcasecmp( aParam, "rgb" ) == 0 )
85e096c3 4382 {
692613e5 4383 aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGB : Image_PixMap::ImgBGR;
4384 aBufferType = Graphic3d_BT_RGB;
85e096c3 4385 }
29cb310a 4386 else if ( strcasecmp( aParam, "hls" ) == 0 )
85e096c3 4387 {
692613e5 4388 aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGB : Image_PixMap::ImgBGR;
4389 aBufferType = Graphic3d_BT_RGB;
85e096c3 4390 toShowHls = Standard_True;
4391 }
29cb310a 4392 else if ( strcasecmp( aParam, "rgbf" ) == 0 )
85e096c3 4393 {
692613e5 4394 aFormat = Image_PixMap::ImgRGBF;
4395 aBufferType = Graphic3d_BT_RGB;
85e096c3 4396 }
29cb310a 4397 else if ( strcasecmp( aParam, "rgba" ) == 0 )
85e096c3 4398 {
692613e5 4399 aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA;
4400 aBufferType = Graphic3d_BT_RGBA;
85e096c3 4401 }
29cb310a 4402 else if ( strcasecmp( aParam, "rgbaf" ) == 0 )
85e096c3 4403 {
692613e5 4404 aFormat = Image_PixMap::ImgRGBAF;
4405 aBufferType = Graphic3d_BT_RGBA;
85e096c3 4406 }
29cb310a 4407 else if ( strcasecmp( aParam, "depth" ) == 0 )
85e096c3 4408 {
692613e5 4409 aFormat = Image_PixMap::ImgGrayF;
4410 aBufferType = Graphic3d_BT_Depth;
85e096c3 4411 }
29cb310a 4412 else if ( strcasecmp( aParam, "name" ) == 0 )
85e096c3 4413 {
4414 toShowName = Standard_True;
4415 }
4416 }
4417
692613e5 4418 Image_PixMap anImage;
4419 if (!anImage.InitTrash (aFormat, aWidth, aHeight))
4420 {
4421 std::cerr << "Image allocation failed\n";
4422 return 1;
4423 }
4424 else if (!aView->ToPixMap (anImage, aWidth, aHeight, aBufferType))
85e096c3 4425 {
4426 std::cerr << "Image dump failed\n";
4427 return 1;
4428 }
4429
4430 Quantity_Parameter anAlpha;
692613e5 4431 Quantity_Color aColor = anImage.PixelColor (anX, anY, anAlpha);
85e096c3 4432 if (toShowName)
4433 {
692613e5 4434 if (aBufferType == Graphic3d_BT_RGBA)
85e096c3 4435 {
64c759f8 4436 theDI << Quantity_Color::StringName (aColor.Name()) << " " << anAlpha;
85e096c3 4437 }
4438 else
4439 {
64c759f8 4440 theDI << Quantity_Color::StringName (aColor.Name());
85e096c3 4441 }
4442 }
4443 else
4444 {
4445 switch (aBufferType)
4446 {
4447 default:
692613e5 4448 case Graphic3d_BT_RGB:
85e096c3 4449 {
4450 if (toShowHls)
4451 {
64c759f8 4452 theDI << aColor.Hue() << " " << aColor.Light() << " " << aColor.Saturation();
85e096c3 4453 }
4454 else
4455 {
64c759f8 4456 theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue();
85e096c3 4457 }
4458 break;
4459 }
692613e5 4460 case Graphic3d_BT_RGBA:
85e096c3 4461 {
64c759f8 4462 theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue() << " " << anAlpha;
85e096c3 4463 break;
4464 }
692613e5 4465 case Graphic3d_BT_Depth:
85e096c3 4466 {
64c759f8 4467 theDI << aColor.Red();
85e096c3 4468 break;
4469 }
4470 }
4471 }
4472
4473 return 0;
4474}
4475
692613e5 4476//==============================================================================
4477//function : VDiffImage
4478//purpose : The draw-command compares two images.
4479//==============================================================================
4480
4481static int VDiffImage (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
4482{
4483 if (theArgNb < 6)
4484 {
4485 theDI << "Not enough arguments.\n";
4486 return 1;
4487 }
4488
4489 // image file names
4490 const char* anImgPathRef = theArgVec[1];
4491 const char* anImgPathNew = theArgVec[2];
4492
4493 // get string tolerance and check its validity
91322f44 4494 Standard_Real aTolColor = Draw::Atof (theArgVec[3]);
692613e5 4495 if (aTolColor < 0.0)
4496 aTolColor = 0.0;
4497 if (aTolColor > 1.0)
4498 aTolColor = 1.0;
4499
91322f44 4500 Standard_Boolean toBlackWhite = (Draw::Atoi (theArgVec[4]) == 1);
4501 Standard_Boolean isBorderFilterOn = (Draw::Atoi (theArgVec[5]) == 1);
692613e5 4502
4503 // image file of difference
4504 const char* aDiffImagePath = (theArgNb >= 7) ? theArgVec[6] : NULL;
4505
4506 // compare the images
4507 Image_Diff aComparer;
4508 if (!aComparer.Init (anImgPathRef, anImgPathNew, toBlackWhite))
4509 {
4510 return 1;
4511 }
4512
4513 aComparer.SetColorTolerance (aTolColor);
4514 aComparer.SetBorderFilterOn (isBorderFilterOn);
4515 Standard_Integer aDiffColorsNb = aComparer.Compare();
4516 theDI << aDiffColorsNb << "\n";
4517
4518 // save image of difference
4519 if (aDiffImagePath != NULL)
4520 {
4521 aComparer.SaveDiffImage (aDiffImagePath);
4522 }
4523
4524 return 0;
4525}
4526
4754e164 4527//=======================================================================
4528//function : VSelect
4529//purpose : Emulates different types of selection by mouse:
4530// 1) single click selection
4531// 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)
4532// 3) selection with polygon having corners at
dc3fe572 4533// pixel positions (x1,y1),...,(xn,yn)
4754e164 4534// 4) any of these selections with shift button pressed
4535//=======================================================================
4536static Standard_Integer VSelect (Draw_Interpretor& di,
4537 Standard_Integer argc,
4538 const char ** argv)
4539{
dc3fe572 4540 if(argc < 3)
4754e164 4541 {
4542 di << "Usage : " << argv[0] << " x1 y1 [x2 y2 [... xn yn]] [shift_selection = 1|0]" << "\n";
4543 return 1;
4544 }
4545
4546 Handle(AIS_InteractiveContext) myAIScontext = ViewerTest::GetAISContext();
dc3fe572 4547 if(myAIScontext.IsNull())
4754e164 4548 {
4549 di << "use 'vinit' command before " << argv[0] << "\n";
4550 return 1;
4551 }
4552 const Standard_Boolean isShiftSelection = (argc>3 && !(argc%2) && (atoi(argv[argc-1])==1));
4553 Handle(ViewerTest_EventManager) aCurrentEventManager = ViewerTest::CurrentEventManager();
4554 aCurrentEventManager->MoveTo(atoi(argv[1]),atoi(argv[2]));
4555 if(argc <= 4)
4556 {
4557 if(isShiftSelection)
4558 aCurrentEventManager->ShiftSelect();
4559 else
4560 aCurrentEventManager->Select();
4561 }
4562 else if(argc <= 6)
4563 {
4564 if(isShiftSelection)
4565 aCurrentEventManager->ShiftSelect(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
4566 else
4567 aCurrentEventManager->Select(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
4568 }
4569 else
4570 {
4571 Standard_Integer anUpper = 0;
4572
4573 if(isShiftSelection)
4574 anUpper = (argc-1)/2;
4575 else
4576 anUpper = argc/2;
4577 TColgp_Array1OfPnt2d aPolyline(1,anUpper);
4578
4579 for(Standard_Integer i=1;i<=anUpper;++i)
4580 aPolyline.SetValue(i,gp_Pnt2d(atoi(argv[2*i-1]),atoi(argv[2*i])));
4581
4582 if(isShiftSelection)
4583 aCurrentEventManager->ShiftSelect(aPolyline);
4584 else
4585 aCurrentEventManager->Select(aPolyline);
4586 }
4587 return 0;
4588}
4589
4590//=======================================================================
4591//function : VMoveTo
dc3fe572 4592//purpose : Emulates cursor movement to defined pixel position
4754e164 4593//=======================================================================
4594static Standard_Integer VMoveTo (Draw_Interpretor& di,
4595 Standard_Integer argc,
4596 const char ** argv)
4597{
dc3fe572 4598 if(argc != 3)
4754e164 4599 {
4600 di << "Usage : " << argv[0] << " x y" << "\n";
4601 return 1;
4602 }
4603
4604 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
dc3fe572 4605 if(aContext.IsNull())
4754e164 4606 {
4607 di << "use 'vinit' command before " << argv[0] << "\n";
4608 return 1;
4609 }
4610 ViewerTest::CurrentEventManager()->MoveTo(atoi(argv[1]),atoi(argv[2]));
4611 return 0;
4612}
4613
197ac94e 4614//=================================================================================================
4754e164 4615//function : VViewParams
dc3fe572 4616//purpose : Gets or sets AIS View characteristics
197ac94e 4617//=================================================================================================
4618static int VViewParams (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
4754e164 4619{
197ac94e 4620 Handle(V3d_View) anAISView = ViewerTest::CurrentView();
4621 if (anAISView.IsNull())
4754e164 4622 {
197ac94e 4623 std::cout << theArgVec[0] << ": please initialize or activate view.\n";
4754e164 4624 return 1;
4625 }
197ac94e 4626
4627 if (theArgsNb == 1)
4754e164 4628 {
197ac94e 4629 // print all of the available view parameters
4630 Quantity_Factor anAISViewScale = anAISView->Scale();
4631
4754e164 4632 Standard_Real anAISViewProjX = 0.0;
4633 Standard_Real anAISViewProjY = 0.0;
4634 Standard_Real anAISViewProjZ = 0.0;
197ac94e 4635 anAISView->Proj (anAISViewProjX, anAISViewProjY, anAISViewProjZ);
4636
4754e164 4637 Standard_Real anAISViewUpX = 0.0;
4638 Standard_Real anAISViewUpY = 0.0;
4639 Standard_Real anAISViewUpZ = 0.0;
197ac94e 4640 anAISView->Up (anAISViewUpX, anAISViewUpY, anAISViewUpZ);
4641
4754e164 4642 Standard_Real anAISViewAtX = 0.0;
4643 Standard_Real anAISViewAtY = 0.0;
4644 Standard_Real anAISViewAtZ = 0.0;
197ac94e 4645 anAISView->At (anAISViewAtX, anAISViewAtY, anAISViewAtZ);
4646
4647 Standard_Real anAISViewEyeX = 0.0;
4648 Standard_Real anAISViewEyeY = 0.0;
4649 Standard_Real anAISViewEyeZ = 0.0;
4650 anAISView->Eye (anAISViewEyeX, anAISViewEyeY, anAISViewEyeZ);
4651
4652 theDi << "Scale of current view: " << anAISViewScale << "\n";
4653 theDi << "Proj on X : " << anAISViewProjX << "; on Y: " << anAISViewProjY << "; on Z: " << anAISViewProjZ << "\n";
4654 theDi << "Up on X : " << anAISViewUpX << "; on Y: " << anAISViewUpY << "; on Z: " << anAISViewUpZ << "\n";
4655 theDi << "At on X : " << anAISViewAtX << "; on Y: " << anAISViewAtY << "; on Z: " << anAISViewAtZ << "\n";
4656 theDi << "Eye on X : " << anAISViewEyeX << "; on Y: " << anAISViewEyeY << "; on Z: " << anAISViewEyeZ << "\n";
4657 return 0;
4754e164 4658 }
197ac94e 4659
4660 // -------------------------
4661 // Parse options and values
4662 // -------------------------
4663
900f7229 4664 NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfKeysByValues;
197ac94e 4665 TCollection_AsciiString aParseKey;
4666 for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
4667 {
4668 TCollection_AsciiString anArg (theArgVec [anArgIt]);
4669
4670 if (anArg.Value (1) == '-' && !anArg.IsRealValue())
4671 {
4672 aParseKey = anArg;
4673 aParseKey.Remove (1);
4674 aParseKey.UpperCase();
900f7229 4675 aMapOfKeysByValues.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
197ac94e 4676 continue;
4677 }
4678
3dfe95cd 4679 if (aParseKey.IsEmpty())
4680 {
4681 std::cout << theArgVec[0] << ": values should be passed with key.\n";
4682 std::cout << "Type help for more information.\n";
4683 return 1;
4684 }
4685
900f7229 4686 aMapOfKeysByValues(aParseKey)->Append (anArg);
197ac94e 4687 }
4688
4689 // ---------------------------------------------
4690 // Change or print parameters, order plays role
4691 // ---------------------------------------------
4692
4693 // Check arguments for validity
900f7229 4694 NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfKeysByValues);
197ac94e 4695 for (; aMapIt.More(); aMapIt.Next())
4754e164 4696 {
197ac94e 4697 const TCollection_AsciiString& aKey = aMapIt.Key();
900f7229 4698 const Handle(TColStd_HSequenceOfAsciiString)& aValues = aMapIt.Value();
4699
4700 if (!(aKey.IsEqual ("SCALE") && (aValues->Length() == 1 || aValues->IsEmpty()))
4701 && !(aKey.IsEqual ("SIZE") && (aValues->Length() == 1 || aValues->IsEmpty()))
4702 && !(aKey.IsEqual ("EYE") && (aValues->Length() == 3 || aValues->IsEmpty()))
4703 && !(aKey.IsEqual ("AT") && (aValues->Length() == 3 || aValues->IsEmpty()))
4704 && !(aKey.IsEqual ("UP") && (aValues->Length() == 3 || aValues->IsEmpty()))
4705 && !(aKey.IsEqual ("PROJ") && (aValues->Length() == 3 || aValues->IsEmpty()))
4706 && !(aKey.IsEqual ("CENTER") && aValues->Length() == 2))
197ac94e 4707 {
4708 TCollection_AsciiString aLowerKey;
4709 aLowerKey = "-";
4710 aLowerKey += aKey;
4711 aLowerKey.LowerCase();
4712 std::cout << theArgVec[0] << ": " << aLowerKey << " is unknown option, or number of arguments is invalid.\n";
4713 std::cout << "Type help for more information.\n";
4714 return 1;
4715 }
4754e164 4716 }
197ac94e 4717
900f7229 4718 Handle(TColStd_HSequenceOfAsciiString) aValues;
197ac94e 4719
4720 // Change view parameters in proper order
4721 if (aMapOfKeysByValues.Find ("SCALE", aValues))
4722 {
900f7229 4723 if (aValues->IsEmpty())
197ac94e 4724 {
4725 theDi << "Scale: " << anAISView->Scale() << "\n";
4726 }
4727 else
4728 {
900f7229 4729 anAISView->SetScale (aValues->Value(1).RealValue());
197ac94e 4730 }
4731 }
3dfe95cd 4732 if (aMapOfKeysByValues.Find ("SIZE", aValues))
4733 {
900f7229 4734 if (aValues->IsEmpty())
3dfe95cd 4735 {
4736 Standard_Real aSizeX = 0.0;
4737 Standard_Real aSizeY = 0.0;
4738 anAISView->Size (aSizeX, aSizeY);
4739 theDi << "Size X: " << aSizeX << " Y: " << aSizeY << "\n";
4740 }
4741 else
4742 {
900f7229 4743 anAISView->SetSize (aValues->Value(1).RealValue());
3dfe95cd 4744 }
4745 }
197ac94e 4746 if (aMapOfKeysByValues.Find ("EYE", aValues))
4747 {
900f7229 4748 if (aValues->IsEmpty())
197ac94e 4749 {
4750 Standard_Real anEyeX = 0.0;
4751 Standard_Real anEyeY = 0.0;
4752 Standard_Real anEyeZ = 0.0;
4753 anAISView->Eye (anEyeX, anEyeY, anEyeZ);
4754 theDi << "Eye X: " << anEyeX << " Y: " << anEyeY << " Z: " << anEyeZ << "\n";
4755 }
4756 else
4757 {
900f7229 4758 anAISView->SetEye (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
197ac94e 4759 }
4760 }
4761 if (aMapOfKeysByValues.Find ("AT", aValues))
4762 {
900f7229 4763 if (aValues->IsEmpty())
197ac94e 4764 {
4765 Standard_Real anAtX = 0.0;
4766 Standard_Real anAtY = 0.0;
4767 Standard_Real anAtZ = 0.0;
4768 anAISView->At (anAtX, anAtY, anAtZ);
4769 theDi << "At X: " << anAtX << " Y: " << anAtY << " Z: " << anAtZ << "\n";
4770 }
4771 else
4772 {
900f7229 4773 anAISView->SetAt (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
197ac94e 4774 }
4775 }
4776 if (aMapOfKeysByValues.Find ("PROJ", aValues))
4777 {
900f7229 4778 if (aValues->IsEmpty())
197ac94e 4779 {
4780 Standard_Real aProjX = 0.0;
4781 Standard_Real aProjY = 0.0;
4782 Standard_Real aProjZ = 0.0;
4783 anAISView->Proj (aProjX, aProjY, aProjZ);
4784 theDi << "Proj X: " << aProjX << " Y: " << aProjY << " Z: " << aProjZ << "\n";
4785 }
4786 else
4787 {
900f7229 4788 anAISView->SetProj (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
197ac94e 4789 }
4790 }
4791 if (aMapOfKeysByValues.Find ("UP", aValues))
4792 {
900f7229 4793 if (aValues->IsEmpty())
197ac94e 4794 {
4795 Standard_Real anUpX = 0.0;
4796 Standard_Real anUpY = 0.0;
4797 Standard_Real anUpZ = 0.0;
4798 anAISView->Up (anUpX, anUpY, anUpZ);
4799 theDi << "Up X: " << anUpX << " Y: " << anUpY << " Z: " << anUpZ << "\n";
4800 }
4801 else
4802 {
900f7229 4803 anAISView->SetUp (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
197ac94e 4804 }
4805 }
4806 if (aMapOfKeysByValues.Find ("CENTER", aValues))
4807 {
900f7229 4808 anAISView->SetCenter (aValues->Value(1).IntegerValue(), aValues->Value(2).IntegerValue());
197ac94e 4809 }
4810
4754e164 4811 return 0;
4812}
4813
4814//=======================================================================
4815//function : VChangeSelected
dc3fe572 4816//purpose : Adds the shape to selection or remove one from it
4754e164 4817//=======================================================================
4818static Standard_Integer VChangeSelected (Draw_Interpretor& di,
4819 Standard_Integer argc,
4820 const char ** argv)
4821{
4822 if(argc != 2)
4823 {
4824 di<<"Usage : " << argv[0] << " shape \n";
4825 return 1;
4826 }
4827 //get AIS_Shape:
4828 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4829 ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
4830 TCollection_AsciiString aName(argv[1]);
4831 Handle(AIS_InteractiveObject) anAISObject;
4832
4833 if(!aMap.IsBound2(aName))
4834 {
4835 di<<"Use 'vdisplay' before";
4836 return 1;
4837 }
4838 else
4839 {
4840 anAISObject = Handle(AIS_InteractiveObject)::DownCast(aMap.Find2(aName));
4841 if(anAISObject.IsNull()){
4842 di<<"No interactive object \n";
4843 return 1;
4844 }
4845
4846 if(aContext->HasOpenedContext())
4847 {
4848 aContext->AddOrRemoveSelected(anAISObject);
4849 }
dc3fe572 4850 else
4754e164 4851 {
4852 aContext->AddOrRemoveCurrentObject(anAISObject);
4853 }
4854 }
4855 return 0;
4856}
4857
4858//=======================================================================
4859//function : VZClipping
dc3fe572 4860//purpose : Gets or sets ZClipping mode, width and depth
4754e164 4861//=======================================================================
4862static Standard_Integer VZClipping (Draw_Interpretor& di,
4863 Standard_Integer argc,
4864 const char ** argv)
4865{
dc3fe572 4866 if(argc>4)
4754e164 4867 {
4868 di << "Usage : " << argv[0] << " [mode] [depth width]" << "\n"
4869 <<"mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
4870 return -1;
4871 }
4872 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
dc3fe572 4873 if(aContext.IsNull())
4754e164 4874 {
4875 di << "use 'vinit' command before " << argv[0] << "\n";
4876 return 1;
4877 }
4878 Handle(V3d_View) aView = ViewerTest::CurrentView();
1d47d8d0 4879 V3d_TypeOfZclipping aZClippingMode = V3d_OFF;
4754e164 4880 if(argc==1)
4881 {
4882 TCollection_AsciiString aZClippingModeString;
4883 Quantity_Length aDepth, aWidth;
4884 aZClippingMode = aView->ZClipping(aDepth, aWidth);
4885 switch (aZClippingMode)
4886 {
4887 case V3d_OFF:
4888 aZClippingModeString.Copy("OFF");
4889 break;
4890 case V3d_BACK:
4891 aZClippingModeString.Copy("BACK");
4892 break;
4893 case V3d_FRONT:
4894 aZClippingModeString.Copy("FRONT");
4895 break;
4896 case V3d_SLICE:
4897 aZClippingModeString.Copy("SLICE");
4898 break;
4899 default:
4900 aZClippingModeString.Copy(TCollection_AsciiString(aZClippingMode));
4901 break;
4902 }
4903 di << "ZClippingMode = " << aZClippingModeString.ToCString() << "\n"
4904 << "ZClipping depth = " << aDepth << "\n"
4905 << "ZClipping width = " << aWidth << "\n";
4906 }
4907 else
4908 {
4909 if(argc !=3)
4910 {
4911 Standard_Integer aStatus = 0;
4912 if ( strcmp (argv [1], "OFF") == 0 ) {
4913 aStatus = 1;
4914 aZClippingMode = V3d_OFF;
4915 }
4916 if ( strcmp (argv [1], "BACK") == 0 ) {
4917 aStatus = 1;
4918 aZClippingMode = V3d_BACK;
4919 }
4920 if ( strcmp (argv [1], "FRONT") == 0 ) {
4921 aStatus = 1;
4922 aZClippingMode = V3d_FRONT;
4923 }
4924 if ( strcmp (argv [1], "SLICE") == 0 ) {
4925 aStatus = 1;
4926 aZClippingMode = V3d_SLICE;
4927 }
4928 if (aStatus != 1)
4929 {
4930 di << "Bad mode; Usage : " << argv[0] << " [mode] [depth width]" << "\n"
4931 << "mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
4932 return 1;
dc3fe572 4933 }
4754e164 4934 aView->SetZClippingType(aZClippingMode);
4935 }
4936 if(argc >2)
4937 {
4938 Quantity_Length aDepth = 0., aWidth = 1.;
4939 if(argc == 3)
4940 {
6b62b2da 4941 aDepth = Draw::Atof (argv[1]);
4942 aWidth = Draw::Atof (argv[2]);
4754e164 4943 }
4944 else if(argc == 4)
4945 {
6b62b2da 4946 aDepth = Draw::Atof (argv[2]);
4947 aWidth = Draw::Atof (argv[3]);
4754e164 4948 }
dc3fe572 4949
4754e164 4950 if(aDepth<0. || aDepth>1.)
4951 {
4952 di << "Bad depth; Usage : " << argv[0] << " [mode] [depth width]" << "\n"
4953 << "mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
4954 return 1;
4955 }
4956 if(aWidth<0. || aWidth>1.)
4957 {
4958 di << "Bad width; Usage : " << argv[0] << " [mode] [depth width]" << "\n"
4959 << "mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
4960 return 1;
4961 }
4962
4963 aView->SetZClippingDepth(aDepth);
4964 aView->SetZClippingWidth(aWidth);
4965 }
4966 aView->Redraw();
4967 }
4968 return 0;
4969}
4970
4971//=======================================================================
4972//function : VNbSelected
dc3fe572 4973//purpose : Returns number of selected objects
4754e164 4974//=======================================================================
4975static Standard_Integer VNbSelected (Draw_Interpretor& di,
4976 Standard_Integer argc,
4977 const char ** argv)
4978{
4979 if(argc != 1)
4980 {
4981 di << "Usage : " << argv[0] << "\n";
4982 return 1;
4983 }
4984 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4985 if(aContext.IsNull())
4986 {
4987 di << "use 'vinit' command before " << argv[0] << "\n";
4988 return 1;
4989 }
4990 di << aContext->NbSelected() << "\n";
4991 return 0;
4992}
4993
4994//=======================================================================
4995//function : VAntialiasing
dc3fe572 4996//purpose : Switches altialiasing on or off
4754e164 4997//=======================================================================
4998static Standard_Integer VAntialiasing (Draw_Interpretor& di,
4999 Standard_Integer argc,
5000 const char ** argv)
5001{
5002 if(argc > 2)
5003 {
5004 di << "Usage : " << argv[0] << " [1|0]" << "\n";
5005 return 1;
5006 }
5007
5008 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
5009 if(aContext.IsNull())
5010 {
5011 di << "use 'vinit' command before " << argv[0] << "\n";
5012 return 1;
5013 }
5014
5015 Handle(V3d_View) aView = ViewerTest::CurrentView();
5016
5017 if((argc == 2) && (atof(argv[1]) == 0))
5018 aView->SetAntialiasingOff();
5019 else
5020 aView->SetAntialiasingOn();
5021 aView->Update();
5022 return 0;
5023}
5024
5025//=======================================================================
5026//function : VPurgeDisplay
dc3fe572 5027//purpose : Switches altialiasing on or off
4754e164 5028//=======================================================================
5029static Standard_Integer VPurgeDisplay (Draw_Interpretor& di,
5030 Standard_Integer argc,
5031 const char ** argv)
5032{
eb4320f2 5033 if (argc > 1)
4754e164 5034 {
eb4320f2 5035 di << "Usage : " << argv[0] << "\n";
4754e164 5036 return 1;
5037 }
4754e164 5038 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
5039 if (aContext.IsNull())
5040 {
5041 di << "use 'vinit' command before " << argv[0] << "\n";
5042 return 1;
5043 }
5044 aContext->CloseAllContexts(Standard_False);
eb4320f2 5045 di << aContext->PurgeDisplay() << "\n";
4754e164 5046 return 0;
5047}
5048
5049//=======================================================================
5050//function : VSetViewSize
5051//purpose :
5052//=======================================================================
5053static Standard_Integer VSetViewSize (Draw_Interpretor& di,
5054 Standard_Integer argc,
5055 const char ** argv)
5056{
5057 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
5058 if(aContext.IsNull())
5059 {
5060 di << "use 'vinit' command before " << argv[0] << "\n";
5061 return 1;
5062 }
5063 if(argc != 2)
5064 {
5065 di<<"Usage : " << argv[0] << " Size\n";
5066 return 1;
5067 }
6b62b2da 5068 Standard_Real aSize = Draw::Atof (argv[1]);
4754e164 5069 if (aSize <= 0.)
5070 {
5071 di<<"Bad Size value : " << aSize << "\n";
5072 return 1;
5073 }
5074
5075 Handle(V3d_View) aView = ViewerTest::CurrentView();
5076 aView->SetSize(aSize);
5077 return 0;
5078}
5079
5080//=======================================================================
5081//function : VMoveView
5082//purpose :
5083//=======================================================================
5084static Standard_Integer VMoveView (Draw_Interpretor& di,
5085 Standard_Integer argc,
5086 const char ** argv)
5087{
5088 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
5089 if(aContext.IsNull())
5090 {
5091 di << "use 'vinit' command before " << argv[0] << "\n";
5092 return 1;
5093 }
5094 if(argc < 4 || argc > 5)
5095 {
5096 di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
5097 return 1;
5098 }
6b62b2da 5099 Standard_Real Dx = Draw::Atof (argv[1]);
5100 Standard_Real Dy = Draw::Atof (argv[2]);
5101 Standard_Real Dz = Draw::Atof (argv[3]);
4754e164 5102 Standard_Boolean aStart = Standard_True;
5103 if (argc == 5)
5104 {
6b62b2da 5105 aStart = (Draw::Atoi (argv[4]) > 0);
4754e164 5106 }
5107
5108 Handle(V3d_View) aView = ViewerTest::CurrentView();
5109 aView->Move(Dx,Dy,Dz,aStart);
5110 return 0;
5111}
5112
5113//=======================================================================
5114//function : VTranslateView
5115//purpose :
5116//=======================================================================
5117static Standard_Integer VTranslateView (Draw_Interpretor& di,
5118 Standard_Integer argc,
5119 const char ** argv)
5120{
5121 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
5122 if(aContext.IsNull())
5123 {
5124 di << "use 'vinit' command before " << argv[0] << "\n";
5125 return 1;
5126 }
5127 if(argc < 4 || argc > 5)
5128 {
5129 di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
5130 return 1;
5131 }
6b62b2da 5132 Standard_Real Dx = Draw::Atof (argv[1]);
5133 Standard_Real Dy = Draw::Atof (argv[2]);
5134 Standard_Real Dz = Draw::Atof (argv[3]);
4754e164 5135 Standard_Boolean aStart = Standard_True;
dc3fe572 5136 if (argc == 5)
4754e164 5137 {
6b62b2da 5138 aStart = (Draw::Atoi (argv[4]) > 0);
4754e164 5139 }
5140
5141 Handle(V3d_View) aView = ViewerTest::CurrentView();
5142 aView->Translate(Dx,Dy,Dz,aStart);
5143 return 0;
5144}
5145
5146//=======================================================================
5147//function : VTurnView
5148//purpose :
5149//=======================================================================
5150static Standard_Integer VTurnView (Draw_Interpretor& di,
5151 Standard_Integer argc,
5152 const char ** argv)
5153{
5154 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
5155 if(aContext.IsNull()) {
5156 di << "use 'vinit' command before " << argv[0] << "\n";
5157 return 1;
5158 }
5159 if(argc < 4 || argc > 5){
5160 di<<"Usage : " << argv[0] << " Ax Ay Az [Start = 1|0]\n";
5161 return 1;
5162 }
6b62b2da 5163 Standard_Real Ax = Draw::Atof (argv[1]);
5164 Standard_Real Ay = Draw::Atof (argv[2]);
5165 Standard_Real Az = Draw::Atof (argv[3]);
4754e164 5166 Standard_Boolean aStart = Standard_True;
dc3fe572 5167 if (argc == 5)
4754e164 5168 {
6b62b2da 5169 aStart = (Draw::Atoi (argv[4]) > 0);
4754e164 5170 }
5171
5172 Handle(V3d_View) aView = ViewerTest::CurrentView();
5173 aView->Turn(Ax,Ay,Az,aStart);
5174 return 0;
5175}
5176
269294d6 5177//==============================================================================
5178//function : VTextureEnv
5179//purpose : ENables or disables environment mapping
5180//==============================================================================
5181class OCC_TextureEnv : public Graphic3d_TextureEnv
5182{
5183public:
5184 OCC_TextureEnv(const Standard_CString FileName);
5185 OCC_TextureEnv(const Graphic3d_NameOfTextureEnv aName);
5186 void SetTextureParameters(const Standard_Boolean theRepeatFlag,
5187 const Standard_Boolean theModulateFlag,
5188 const Graphic3d_TypeOfTextureFilter theFilter,
5189 const Standard_ShortReal theXScale,
5190 const Standard_ShortReal theYScale,
5191 const Standard_ShortReal theXShift,
5192 const Standard_ShortReal theYShift,
5193 const Standard_ShortReal theAngle);
5194 DEFINE_STANDARD_RTTI(OCC_TextureEnv);
5195};
5196DEFINE_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv);
5197IMPLEMENT_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv);
5198IMPLEMENT_STANDARD_RTTIEXT(OCC_TextureEnv, Graphic3d_TextureEnv);
5199
5200OCC_TextureEnv::OCC_TextureEnv(const Standard_CString theFileName)
5201 : Graphic3d_TextureEnv(theFileName)
5202{
5203}
5204
5205OCC_TextureEnv::OCC_TextureEnv(const Graphic3d_NameOfTextureEnv theTexId)
5206 : Graphic3d_TextureEnv(theTexId)
5207{
5208}
5209
5210void OCC_TextureEnv::SetTextureParameters(const Standard_Boolean theRepeatFlag,
5211 const Standard_Boolean theModulateFlag,
5212 const Graphic3d_TypeOfTextureFilter theFilter,
5213 const Standard_ShortReal theXScale,
5214 const Standard_ShortReal theYScale,
5215 const Standard_ShortReal theXShift,
5216 const Standard_ShortReal theYShift,
5217 const Standard_ShortReal theAngle)
5218{
5219 myParams->SetRepeat (theRepeatFlag);
5220 myParams->SetModulate (theModulateFlag);
5221 myParams->SetFilter (theFilter);
5222 myParams->SetScale (Graphic3d_Vec2(theXScale, theYScale));
5223 myParams->SetTranslation(Graphic3d_Vec2(theXShift, theYShift));
5224 myParams->SetRotation (theAngle);
5225}
5226
35e08fe8 5227static int VTextureEnv (Draw_Interpretor& /*theDI*/, Standard_Integer theArgNb, const char** theArgVec)
269294d6 5228{
5229 // get the active view
5230 Handle(V3d_View) aView = ViewerTest::CurrentView();
5231 if (aView.IsNull())
5232 {
5233 std::cerr << "No active view. Please call vinit.\n";
5234 return 1;
5235 }
5236
5237 // Checking the input arguments
5238 Standard_Boolean anEnableFlag = Standard_False;
5239 Standard_Boolean isOk = theArgNb >= 2;
5240 if (isOk)
5241 {
5242 TCollection_AsciiString anEnableOpt(theArgVec[1]);
5243 anEnableFlag = anEnableOpt.IsEqual("on");
5244 isOk = anEnableFlag || anEnableOpt.IsEqual("off");
5245 }
5246 if (anEnableFlag)
5247 {
5248 isOk = (theArgNb == 3 || theArgNb == 11);
5249 if (isOk)
5250 {
5251 TCollection_AsciiString aTextureOpt(theArgVec[2]);
5252 isOk = (!aTextureOpt.IsIntegerValue() ||
5253 (aTextureOpt.IntegerValue() >= 0 && aTextureOpt.IntegerValue() < Graphic3d_NOT_ENV_UNKNOWN));
5254
5255 if (isOk && theArgNb == 11)
5256 {
5257 TCollection_AsciiString aRepeatOpt (theArgVec[3]),
5258 aModulateOpt(theArgVec[4]),
5259 aFilterOpt (theArgVec[5]),
5260 aSScaleOpt (theArgVec[6]),
5261 aTScaleOpt (theArgVec[7]),
5262 aSTransOpt (theArgVec[8]),
5263 aTTransOpt (theArgVec[9]),
5264 anAngleOpt (theArgVec[10]);
5265 isOk = ((aRepeatOpt. IsEqual("repeat") || aRepeatOpt. IsEqual("clamp")) &&
5266 (aModulateOpt.IsEqual("modulate") || aModulateOpt.IsEqual("decal")) &&
5267 (aFilterOpt. IsEqual("nearest") || aFilterOpt. IsEqual("bilinear") || aFilterOpt.IsEqual("trilinear")) &&
5268 aSScaleOpt.IsRealValue() && aTScaleOpt.IsRealValue() &&
5269 aSTransOpt.IsRealValue() && aTTransOpt.IsRealValue() &&
5270 anAngleOpt.IsRealValue());
5271 }
5272 }
5273 }
5274
5275 if (!isOk)
5276 {
5277 std::cerr << "Usage :" << std::endl;
5278 std::cerr << theArgVec[0] << " off" << std::endl;
5279 std::cerr << theArgVec[0] << " on {index_of_std_texture(0..7)|texture_file_name} [{clamp|repeat} {decal|modulate} {nearest|bilinear|trilinear} scale_s scale_t translation_s translation_t rotation_degrees]" << std::endl;
5280 return 1;
5281 }
5282
5283 if (anEnableFlag)
5284 {
5285 TCollection_AsciiString aTextureOpt(theArgVec[2]);
5286 Handle(OCC_TextureEnv) aTexEnv = aTextureOpt.IsIntegerValue() ?
5287 new OCC_TextureEnv((Graphic3d_NameOfTextureEnv)aTextureOpt.IntegerValue()) :
5288 new OCC_TextureEnv(theArgVec[2]);
5289
5290 if (theArgNb == 11)
5291 {
5292 TCollection_AsciiString aRepeatOpt(theArgVec[3]), aModulateOpt(theArgVec[4]), aFilterOpt(theArgVec[5]);
5293 aTexEnv->SetTextureParameters(
5294 aRepeatOpt. IsEqual("repeat"),
5295 aModulateOpt.IsEqual("modulate"),
5296 aFilterOpt. IsEqual("nearest") ? Graphic3d_TOTF_NEAREST :
5297 aFilterOpt.IsEqual("bilinear") ? Graphic3d_TOTF_BILINEAR :
5298 Graphic3d_TOTF_TRILINEAR,
5299 (Standard_ShortReal)Draw::Atof(theArgVec[6]),
5300 (Standard_ShortReal)Draw::Atof(theArgVec[7]),
5301 (Standard_ShortReal)Draw::Atof(theArgVec[8]),
5302 (Standard_ShortReal)Draw::Atof(theArgVec[9]),
5303 (Standard_ShortReal)Draw::Atof(theArgVec[10])
5304 );
5305 }
5306 aView->SetTextureEnv(aTexEnv);
5307 aView->SetSurfaceDetail(V3d_TEX_ENVIRONMENT);
5308 }
5309 else // Disabling environment mapping
5310 {
5311 aView->SetSurfaceDetail(V3d_TEX_NONE);
5312 Handle(Graphic3d_TextureEnv) aTexture;
5313 aView->SetTextureEnv(aTexture); // Passing null handle to clear the texture data
5314 }
5315
5316 aView->Redraw();
5317 return 0;
5318}
5319
4269bd1b 5320//===============================================================================================
5321//function : VClipPlane
5322//purpose :
5323//===============================================================================================
5324static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
5325{
5326 // use short-cut for created clip planes map of created (or "registered by name") clip planes
5327 typedef NCollection_DataMap<TCollection_AsciiString, Handle(Graphic3d_ClipPlane)> MapOfPlanes;
5328 static MapOfPlanes aRegPlanes;
5329
5330 if (theArgsNb < 2)
5331 {
5332 theDi << theArgVec[0] << ": command argument is required. Type help for more information.\n";
5333 return 1;
5334 }
5335
5336 TCollection_AsciiString aCommand (theArgVec[1]);
5337
5338 // print maximum number of planes for current viewer
5339 if (aCommand == "maxplanes")
5340 {
5341 if (theArgsNb < 3)
5342 {
5343 theDi << theArgVec[0] << ": view name is required. Type help for more information.\n";
5344 return 1;
5345 }
5346
5347 TCollection_AsciiString aViewName (theArgVec[2]);
5348
5349 if (!ViewerTest_myViews.IsBound1 (aViewName))
5350 {
5351 theDi << theArgVec[0] << ": view is not found.\n";
5352 return 1;
5353 }
5354
5355 const Handle(V3d_View)& aView = ViewerTest_myViews.Find1 (aViewName);
5356
5357 theDi << theArgVec[0] << ": "
5358 << aView->Viewer()->Driver()->InquirePlaneLimit()
5359 << " plane slots provided by driver."
5360 << " Note that 2 more planes might be used (reserved for z-clipping).\n";
5361
5362 return 0;
5363 }
5364
5365 // create / delete plane instance
5366 if (aCommand == "create" || aCommand == "delete" || aCommand == "clone")
5367 {
5368 if (theArgsNb < 3)
5369 {
5370 theDi << theArgVec[0] << ": plane name is required. Type help for more information.\n";
5371 return 1;
5372 }
5373
5374 Standard_Boolean toCreate = (aCommand == "create");
5375 Standard_Boolean toClone = (aCommand == "clone");
5376 TCollection_AsciiString aPlane (theArgVec[2]);
5377
5378 if (toCreate)
5379 {
5380 if (aRegPlanes.IsBound (aPlane))
5381 {
5382 theDi << theArgVec[0] << ": plane name is in use.\n";
5383 return 1;
5384 }
5385
5386 aRegPlanes.Bind (aPlane, new Graphic3d_ClipPlane());
5387 }
5388 else if (toClone) // toClone
5389 {
5390 if (!aRegPlanes.IsBound (aPlane))
5391 {
5392 theDi << theArgVec[0] << ": no such plane.\n";
5393 return 1;
5394 }
5395
5396 if (theArgsNb < 4)
5397 {
5398 theDi << theArgVec[0] << ": enter name for new plane. Type help for more information.\n";
5399 return 1;
5400 }
5401
5402 TCollection_AsciiString aClone (theArgVec[3]);
5403 if (aRegPlanes.IsBound (aClone))
5404 {
5405 theDi << theArgVec[0] << ": plane name is in use.\n";
5406 return 1;
5407 }
5408
5409 const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
5410
5411 aRegPlanes.Bind (aClone, aClipPlane->Clone());
5412 }
5413 else// toDelete
5414 {
5415 if (!aRegPlanes.IsBound (aPlane))
5416 {
5417 theDi << theArgVec[0] << ": no such plane.\n";
5418 return 1;
5419 }
5420
5421 Handle(Graphic3d_ClipPlane) aClipPlane = aRegPlanes.Find (aPlane);
5422 aRegPlanes.UnBind (aPlane);
5423
5424 ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIObjIt (GetMapOfAIS());
5425 for (; anIObjIt.More(); anIObjIt.Next())
5426 {
5427 Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anIObjIt.Key1());
5428 aPrs->RemoveClipPlane(aClipPlane);
5429 }
5430
5431 NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
5432 for (; aViewIt.More(); aViewIt.Next())
5433 {
5434 const Handle(V3d_View)& aView = aViewIt.Key2();
5435 aView->RemoveClipPlane(aClipPlane);
5436 }
5437
5438 ViewerTest::RedrawAllViews();
5439 }
5440
5441 return 0;
5442 }
5443
5444 // set / unset plane command
5445 if (aCommand == "set" || aCommand == "unset")
5446 {
5447 if (theArgsNb < 4)
5448 {
5449 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5450 return 1;
5451 }
5452
5453 Standard_Boolean toSet = (aCommand == "set");
5454 TCollection_AsciiString aPlane (theArgVec [2]);
5455 if (!aRegPlanes.IsBound (aPlane))
5456 {
5457 theDi << theArgVec[0] << ": no such plane.\n";
5458 return 1;
5459 }
5460
5461 const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
5462
5463 TCollection_AsciiString aTarget (theArgVec [3]);
5464 if (aTarget != "object" && aTarget != "view")
5465 {
5466 theDi << theArgVec[0] << ": invalid target.\n";
5467 return 1;
5468 }
5469
5470 if (aTarget == "object" || aTarget == "view")
5471 {
5472 if (theArgsNb < 5)
5473 {
5474 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5475 return 1;
5476 }
5477
5478 Standard_Boolean isObject = (aTarget == "object");
5479
5480 for (Standard_Integer anIt = 4; anIt < theArgsNb; ++anIt)
5481 {
5482 TCollection_AsciiString anEntityName (theArgVec[anIt]);
5483 if (isObject) // to object
5484 {
5485 if (!GetMapOfAIS().IsBound2 (anEntityName))
5486 {
5487 theDi << theArgVec[0] << ": can not find IO with name " << anEntityName << ".\n";
5488 continue;
5489 }
5490
5491 Handle(AIS_InteractiveObject) aIObj =
5492 Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (anEntityName));
5493
5494 if (toSet)
5495 aIObj->AddClipPlane (aClipPlane);
5496 else
5497 aIObj->RemoveClipPlane (aClipPlane);
5498 }
5499 else // to view
5500 {
5501 if (!ViewerTest_myViews.IsBound1 (anEntityName))
5502 {
5503 theDi << theArgVec[0] << ": can not find View with name " << anEntityName << ".\n";
5504 continue;
5505 }
5506
5507 Handle(V3d_View) aView = ViewerTest_myViews.Find1(anEntityName);
5508 if (toSet)
5509 aView->AddClipPlane (aClipPlane);
5510 else
5511 aView->RemoveClipPlane (aClipPlane);
5512 }
5513 }
5514
5515 ViewerTest::RedrawAllViews();
5516 }
5517
5518 return 0;
5519 }
5520
5521 // change plane command
5522 if (aCommand == "change")
5523 {
5524 if (theArgsNb < 4)
5525 {
5526 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5527 return 1;
5528 }
5529
5530 TCollection_AsciiString aPlane (theArgVec [2]);
5531 if (!aRegPlanes.IsBound (aPlane))
5532 {
5533 theDi << theArgVec[0] << ": no such plane.\n";
5534 return 1;
5535 }
5536
5537 const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
5538
5539 TCollection_AsciiString aChangeArg (theArgVec [3]);
5540 if (aChangeArg != "on" && aChangeArg != "off" && aChangeArg != "capping" && aChangeArg != "equation")
5541 {
5542 theDi << theArgVec[0] << ": invalid arguments. Type help for more information.\n";
5543 return 1;
5544 }
5545
5546 if (aChangeArg == "on" || aChangeArg == "off") // on / off
5547 {
5548 aClipPlane->SetOn (aChangeArg == "on");
5549 }
5550 else if (aChangeArg == "equation") // change equation
5551 {
5552 if (theArgsNb < 8)
5553 {
5554 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5555 return 1;
5556 }
5557
6b62b2da 5558 Standard_Real aCoeffA = Draw::Atof (theArgVec [4]);
5559 Standard_Real aCoeffB = Draw::Atof (theArgVec [5]);
5560 Standard_Real aCoeffC = Draw::Atof (theArgVec [6]);
5561 Standard_Real aCoeffD = Draw::Atof (theArgVec [7]);
4269bd1b 5562 aClipPlane->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
5563 }
5564 else if (aChangeArg == "capping") // change capping aspects
5565 {
5566 if (theArgsNb < 5)
5567 {
5568 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5569 return 1;
5570 }
5571
5572 TCollection_AsciiString aCappingArg (theArgVec [4]);
5573 if (aCappingArg != "on" && aCappingArg != "off" &&
5574 aCappingArg != "color" && aCappingArg != "texname" &&
5575 aCappingArg != "texscale" && aCappingArg != "texorigin" &&
5576 aCappingArg != "texrotate" && aCappingArg != "hatch")
5577 {
5578 theDi << theArgVec[0] << ": invalid arguments. Type help for more information.\n";
5579 return 1;
5580 }
5581
5582 if (aCappingArg == "on" || aCappingArg == "off") // on / off capping
5583 {
5584 aClipPlane->SetCapping (aCappingArg == "on");
5585 }
5586 else if (aCappingArg == "color") // color aspect for capping
5587 {
5588 if (theArgsNb < 8)
5589 {
5590 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5591 return 1;
5592 }
5593
6b62b2da 5594 Standard_Real aRed = Draw::Atof (theArgVec [5]);
5595 Standard_Real aGrn = Draw::Atof (theArgVec [6]);
5596 Standard_Real aBlu = Draw::Atof (theArgVec [7]);
4269bd1b 5597
5598 Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
8aeeca44 5599 Quantity_Color aColor (aRed, aGrn, aBlu, Quantity_TOC_RGB);
5600 aMat.SetAmbientColor (aColor);
5601 aMat.SetDiffuseColor (aColor);
4269bd1b 5602 aClipPlane->SetCappingMaterial (aMat);
5603 }
5604 else if (aCappingArg == "texname") // texture name
5605 {
5606 if (theArgsNb < 6)
5607 {
5608 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5609 return 1;
5610 }
5611
5612 TCollection_AsciiString aTextureName (theArgVec [5]);
5613
5614 Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
5615 if (!aTexture->IsDone ())
5616 {
5617 aClipPlane->SetCappingTexture (NULL);
5618 }
5619 else
5620 {
5621 aTexture->EnableModulate();
5622 aTexture->EnableRepeat();
5623 aClipPlane->SetCappingTexture (aTexture);
5624 }
5625 }
5626 else if (aCappingArg == "texscale") // texture scale
5627 {
5628 if (aClipPlane->CappingTexture().IsNull())
5629 {
5630 theDi << theArgVec[0] << ": no texture is set.\n";
5631 return 1;
5632 }
5633
5634 if (theArgsNb < 7)
5635 {
5636 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5637 return 1;
5638 }
5639
5640 Standard_ShortReal aSx = (Standard_ShortReal)atof (theArgVec [5]);
5641 Standard_ShortReal aSy = (Standard_ShortReal)atof (theArgVec [6]);
5642
5643 aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
5644 }
5645 else if (aCappingArg == "texorigin") // texture origin
5646 {
5647 if (aClipPlane->CappingTexture().IsNull())
5648 {
5649 theDi << theArgVec[0] << ": no texture is set.\n";
5650 return 1;
5651 }
5652
5653 if (theArgsNb < 7)
5654 {
5655 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5656 return 1;
5657 }
5658
5659 Standard_ShortReal aTx = (Standard_ShortReal)atof (theArgVec [5]);
5660 Standard_ShortReal aTy = (Standard_ShortReal)atof (theArgVec [6]);
5661
5662 aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
5663 }
5664 else if (aCappingArg == "texrotate") // texture rotation
5665 {
5666 if (aClipPlane->CappingTexture().IsNull())
5667 {
5668 theDi << theArgVec[0] << ": no texture is set.\n";
5669 return 1;
5670 }
5671
5672 if (theArgsNb < 6)
5673 {
5674 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5675 return 1;
5676 }
5677
5678 Standard_ShortReal aRot = (Standard_ShortReal)atof (theArgVec[5]);
5679
5680 aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
5681 }
5682 else if (aCappingArg == "hatch") // hatch style
5683 {
5684 if (theArgsNb < 6)
5685 {
5686 theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
5687 return 1;
5688 }
5689
5690 TCollection_AsciiString aHatchStr (theArgVec [5]);
5691 if (aHatchStr == "on")
5692 {
5693 aClipPlane->SetCappingHatchOn();
5694 }
5695 else if (aHatchStr == "off")
5696 {
5697 aClipPlane->SetCappingHatchOff();
5698 }
5699 else
5700 {
5701 aClipPlane->SetCappingHatch ((Aspect_HatchStyle)atoi (theArgVec[5]));
5702 }
5703 }
5704 }
5705
5706 ViewerTest::RedrawAllViews();
5707
5708 return 0;
5709 }
5710
5711 theDi << theArgVec[0] << ": invalid command. Type help for more information.\n";
5712 return 1;
5713}
5714
5715//===============================================================================================
5716//function : VSetTextureMode
5717//purpose :
5718//===============================================================================================
5719static int VSetTextureMode (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
5720{
5721 if (theArgsNb < 3)
5722 {
5723 theDi << theArgVec[0] << ": insufficient command arguments. Type help for more information.\n";
5724 return 1;
5725 }
5726
5727 TCollection_AsciiString aViewName (theArgVec[1]);
5728 if (!ViewerTest_myViews.IsBound1 (aViewName))
5729 {
5730 theDi << theArgVec[0] << ": view is not found.\n";
5731 return 1;
5732 }
5733
5734 const Handle(V3d_View)& aView = ViewerTest_myViews.Find1 (aViewName);
5735 switch (atoi (theArgVec[2]))
5736 {
5737 case 0: aView->SetSurfaceDetail (V3d_TEX_NONE); break;
5738 case 1: aView->SetSurfaceDetail (V3d_TEX_ENVIRONMENT); break;
5739 case 2: aView->SetSurfaceDetail (V3d_TEX_ALL); break;
5740 default:
5741 theDi << theArgVec[0] << ": invalid mode.\n";
5742 return 1;
5743 }
5744
5745 aView->Redraw();
5746 return 0;
5747}
5748
b5ac8292 5749//===============================================================================================
5750//function : VZRange
5751//purpose :
5752//===============================================================================================
5753static int VZRange (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
5754{
197ac94e 5755 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
5756
5757 if (aCurrentView.IsNull())
b5ac8292 5758 {
197ac94e 5759 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
b5ac8292 5760 return 1;
5761 }
5762
197ac94e 5763 Handle(Graphic3d_Camera) aCamera = aCurrentView->Camera();
b5ac8292 5764
5765 if (theArgsNb < 2)
5766 {
5767 theDi << "ZNear: " << aCamera->ZNear() << "\n";
5768 theDi << "ZFar: " << aCamera->ZFar() << "\n";
5769 return 0;
5770 }
5771
5772 if (theArgsNb == 3)
5773 {
6b62b2da 5774 Standard_Real aNewZNear = Draw::Atof (theArgVec[1]);
5775 Standard_Real aNewZFar = Draw::Atof (theArgVec[2]);
197ac94e 5776
5777 if (aNewZNear >= aNewZFar)
5778 {
5779 std::cout << theArgVec[0] << ": invalid arguments: znear should be less than zfar.\n";
5780 return 1;
5781 }
5782
5783 if (!aCamera->IsOrthographic() && (aNewZNear <= 0.0 || aNewZFar <= 0.0))
5784 {
5785 std::cout << theArgVec[0] << ": invalid arguments: ";
5786 std::cout << "znear, zfar should be positive for perspective camera.\n";
5787 return 1;
5788 }
5789
5790 aCamera->SetZRange (aNewZNear, aNewZFar);
b5ac8292 5791 }
5792 else
5793 {
197ac94e 5794 std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
b5ac8292 5795 return 1;
5796 }
5797
197ac94e 5798 aCurrentView->Redraw();
5799
b5ac8292 5800 return 0;
5801}
5802
5803//===============================================================================================
5804//function : VAutoZFit
5805//purpose :
5806//===============================================================================================
5807static int VAutoZFit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
5808{
197ac94e 5809 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
5810
5811 if (aCurrentView.IsNull())
b5ac8292 5812 {
197ac94e 5813 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
b5ac8292 5814 return 1;
5815 }
5816
6bc6a6fc 5817 Standard_Real aScale = aCurrentView->View()->AutoZFitScaleFactor();
197ac94e 5818
5819 if (theArgsNb > 3)
b5ac8292 5820 {
197ac94e 5821 std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
5822 return 1;
b5ac8292 5823 }
5824
197ac94e 5825 if (theArgsNb < 2)
b5ac8292 5826 {
197ac94e 5827 theDi << "Auto z-fit mode: " << "\n"
6bc6a6fc 5828 << "On: " << (aCurrentView->View()->AutoZFitMode() ? "enabled" : "disabled") << "\n"
197ac94e 5829 << "Scale: " << aScale << "\n";
5830 return 0;
b5ac8292 5831 }
197ac94e 5832
5833 Standard_Boolean isOn = Draw::Atoi (theArgVec[1]) == 1;
5834
5835 if (theArgsNb >= 3)
b5ac8292 5836 {
197ac94e 5837 aScale = Draw::Atoi (theArgVec[2]);
b5ac8292 5838 }
5839
6bc6a6fc 5840 aCurrentView->View()->SetAutoZFitMode (isOn, aScale);
5841 aCurrentView->View()->AutoZFit();
197ac94e 5842 aCurrentView->Redraw();
5843
b5ac8292 5844 return 0;
5845}
5846
6b62b2da 5847//! Auxiliary function to print projection type
5848inline const char* projTypeName (Graphic3d_Camera::Projection theProjType)
5849{
5850 switch (theProjType)
5851 {
5852 case Graphic3d_Camera::Projection_Orthographic: return "orthographic";
5853 case Graphic3d_Camera::Projection_Perspective: return "perspective";
5854 case Graphic3d_Camera::Projection_Stereo: return "stereoscopic";
5855 case Graphic3d_Camera::Projection_MonoLeftEye: return "monoLeftEye";
5856 case Graphic3d_Camera::Projection_MonoRightEye: return "monoRightEye";
5857 }
5858 return "UNKNOWN";
5859}
5860
b5ac8292 5861//===============================================================================================
6b62b2da 5862//function : VCamera
b5ac8292 5863//purpose :
5864//===============================================================================================
6b62b2da 5865static int VCamera (Draw_Interpretor& theDI,
5866 Standard_Integer theArgsNb,
5867 const char** theArgVec)
b5ac8292 5868{
6b62b2da 5869 Handle(V3d_View) aView = ViewerTest::CurrentView();
5870 if (aView.IsNull())
b5ac8292 5871 {
6b62b2da 5872 std::cout << "Error: no active view.\n";
b5ac8292 5873 return 1;
5874 }
5875
6b62b2da 5876 Handle(Graphic3d_Camera) aCamera = aView->Camera();
5877 if (theArgsNb < 2)
b5ac8292 5878 {
6b62b2da 5879 theDI << "ProjType: " << projTypeName (aCamera->ProjectionType()) << "\n";
5880 theDI << "FOVy: " << aCamera->FOVy() << "\n";
5881 theDI << "Distance: " << aCamera->Distance() << "\n";
5882 theDI << "IOD: " << aCamera->IOD() << "\n";
5883 theDI << "IODType: " << (aCamera->GetIODType() == Graphic3d_Camera::IODType_Absolute ? "absolute" : "relative") << "\n";
5884 theDI << "ZFocus: " << aCamera->ZFocus() << "\n";
5885 theDI << "ZFocusType: " << (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Absolute ? "absolute" : "relative") << "\n";
5886 return 0;
b5ac8292 5887 }
5888
6b62b2da 5889 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
b5ac8292 5890 {
6b62b2da 5891 Standard_CString anArg = theArgVec[anArgIter];
5892 TCollection_AsciiString anArgCase (anArg);
5893 anArgCase.LowerCase();
5894 if (anArgCase == "-proj"
5895 || anArgCase == "-projection"
5896 || anArgCase == "-projtype"
5897 || anArgCase == "-projectiontype")
5898 {
5899 theDI << projTypeName (aCamera->ProjectionType()) << " ";
5900 }
5901 else if (anArgCase == "-ortho"
5902 || anArgCase == "-orthographic")
b5ac8292 5903 {
5904 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
6b62b2da 5905 }
5906 else if (anArgCase == "-persp"
5907 || anArgCase == "-perspective"
5908 || anArgCase == "-perspmono"
5909 || anArgCase == "-perspectivemono"
5910 || anArgCase == "-mono")
b5ac8292 5911 {
5912 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
5913 }
6b62b2da 5914 else if (anArgCase == "-stereo"
5915 || anArgCase == "-stereoscopic"
5916 || anArgCase == "-perspstereo"
5917 || anArgCase == "-perspectivestereo")
5918 {
5919 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
5920 }
5921 else if (anArgCase == "-left"
5922 || anArgCase == "-lefteye"
5923 || anArgCase == "-monoleft"
5924 || anArgCase == "-monolefteye"
5925 || anArgCase == "-perpsleft"
5926 || anArgCase == "-perpslefteye")
b5ac8292 5927 {
5928 aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
5929 }
6b62b2da 5930 else if (anArgCase == "-right"
5931 || anArgCase == "-righteye"
5932 || anArgCase == "-monoright"
5933 || anArgCase == "-monorighteye"
5934 || anArgCase == "-perpsright")
b5ac8292 5935 {
5936 aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
5937 }
6b62b2da 5938 else if (anArgCase == "-dist"
5939 || anArgCase == "-distance")
b5ac8292 5940 {
6b62b2da 5941 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
5942 if (anArgValue != NULL
5943 && *anArgValue != '-')
5944 {
5945 ++anArgIter;
5946 aCamera->SetDistance (Draw::Atof (anArgValue));
5947 continue;
5948 }
5949 theDI << aCamera->Distance() << " ";
b5ac8292 5950 }
6b62b2da 5951 else if (anArgCase == "-iod")
b5ac8292 5952 {
6b62b2da 5953 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
5954 if (anArgValue != NULL
5955 && *anArgValue != '-')
5956 {
5957 ++anArgIter;
5958 aCamera->SetIOD (aCamera->GetIODType(), Draw::Atof (anArgValue));
5959 continue;
5960 }
5961 theDI << aCamera->IOD() << " ";
b5ac8292 5962 }
6b62b2da 5963 else if (anArgCase == "-iodtype")
b5ac8292 5964 {
6b62b2da 5965 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
5966 TCollection_AsciiString anValueCase (anArgValue);
5967 anValueCase.LowerCase();
5968 if (anValueCase == "abs"
5969 || anValueCase == "absolute")
5970 {
5971 ++anArgIter;
5972 aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
5973 continue;
5974 }
5975 else if (anValueCase == "rel"
5976 || anValueCase == "relative")
5977 {
5978 ++anArgIter;
5979 aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
5980 continue;
5981 }
5982 else if (*anArgValue != '-')
5983 {
5984 std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
5985 return 1;
5986 }
5987 switch (aCamera->GetIODType())
5988 {
5989 case Graphic3d_Camera::IODType_Absolute: theDI << "absolute "; break;
5990 case Graphic3d_Camera::IODType_Relative: theDI << "relative "; break;
5991 }
b5ac8292 5992 }
6b62b2da 5993 else if (anArgCase == "-zfocus")
b5ac8292 5994 {
6b62b2da 5995 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
5996 if (anArgValue != NULL
5997 && *anArgValue != '-')
5998 {
5999 ++anArgIter;
6000 aCamera->SetZFocus (aCamera->ZFocusType(), Draw::Atof (anArgValue));
6001 continue;
6002 }
6003 theDI << aCamera->ZFocus() << " ";
b5ac8292 6004 }
6b62b2da 6005 else if (anArgCase == "-zfocustype")
b5ac8292 6006 {
6b62b2da 6007 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
6008 TCollection_AsciiString anValueCase (anArgValue);
6009 anValueCase.LowerCase();
6010 if (anValueCase == "abs"
6011 || anValueCase == "absolute")
6012 {
6013 ++anArgIter;
6014 aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
6015 continue;
6016 }
6017 else if (anValueCase == "rel"
6018 || anValueCase == "relative")
6019 {
6020 ++anArgIter;
6021 aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
6022 continue;
6023 }
6024 else if (*anArgValue != '-')
6025 {
6026 std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
6027 return 1;
6028 }
6029 switch (aCamera->ZFocusType())
6030 {
6031 case Graphic3d_Camera::FocusType_Absolute: theDI << "absolute "; break;
6032 case Graphic3d_Camera::FocusType_Relative: theDI << "relative "; break;
6033 }
6034 }
6035 else if (anArgCase == "-fov"
6036 || anArgCase == "-fovy")
b5ac8292 6037 {
6b62b2da 6038 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
6039 if (anArgValue != NULL
6040 && *anArgValue != '-')
6041 {
6042 ++anArgIter;
6043 aCamera->SetFOVy (Draw::Atof (anArgValue));
6044 continue;
6045 }
6046 theDI << aCamera->FOVy() << " ";
b5ac8292 6047 }
6048 else
6049 {
6b62b2da 6050 std::cout << "Error: unknown argument '" << anArg << "'\n";
b5ac8292 6051 return 1;
6052 }
6053 }
b5ac8292 6054
6b62b2da 6055 aView->View()->AutoZFit();
6056 aView->Redraw();
b5ac8292 6057
6058 return 0;
6059}
6060
6061//==============================================================================
6062//function : VStereo
6063//purpose :
6064//==============================================================================
6065
6066static int VStereo (Draw_Interpretor& theDI,
6067 Standard_Integer theArgNb,
6068 const char** theArgVec)
6069{
6070 if (theArgNb < 2)
6071 {
6072 Handle(V3d_View) aView = ViewerTest::CurrentView();
6073 if (aView.IsNull())
6074 {
6075 std::cerr << "No active view. Please call vinit.\n";
6076 return 0;
6077 }
6078
6079 Standard_Boolean isActive = ViewerTest_myDefaultCaps.contextStereo;
6080 theDI << "Stereo " << (isActive ? "ON" : "OFF") << "\n";
6081 return 0;
6082 }
6083
6084 ViewerTest_myDefaultCaps.contextStereo = Draw::Atoi (theArgVec[1]) != 0;
6085 return 0;
6086}
6087
392ac980 6088//===============================================================================================
6089//function : VDefaults
6090//purpose :
6091//===============================================================================================
6092static int VDefaults (Draw_Interpretor& theDi,
6093 Standard_Integer theArgsNb,
6094 const char** theArgVec)
6095{
6096 const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
6097 if (aCtx.IsNull())
6098 {
6099 std::cerr << "No active viewer!\n";
6100 return 1;
6101 }
6102
6103 Handle(Prs3d_Drawer) aDefParams = aCtx->DefaultDrawer();
6104 if (theArgsNb < 2)
6105 {
6106 if (aDefParams->TypeOfDeflection() == Aspect_TOD_RELATIVE)
6107 {
6108 theDi << "DeflType: relative\n"
6109 << "DeviationCoeff: " << aDefParams->DeviationCoefficient() << "\n";
6110 }
6111 else
6112 {
6113 theDi << "DeflType: absolute\n"
6114 << "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
6115 }
6116 theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
6117 return 0;
6118 }
6119
6120 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
6121 {
6122 TCollection_AsciiString anArg (theArgVec[anArgIter]);
6123 TCollection_AsciiString aKey, aValue;
1d7ca641 6124 if (!ViewerTest::SplitParameter (anArg, aKey, aValue)
392ac980 6125 || aValue.IsEmpty())
6126 {
6127 std::cerr << "Error, wrong syntax at: '" << anArg.ToCString() << "'!\n";
6128 return 1;
6129 }
6130
6131 aKey.UpperCase();
6132 if (aKey == "ABSDEFL"
6133 || aKey == "ABSOLUTEDEFLECTION"
6134 || aKey == "DEFL"
6135 || aKey == "DEFLECTION")
6136 {
6137 aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
6138 aDefParams->SetMaximalChordialDeviation (aValue.RealValue());
6139 }
6140 else if (aKey == "RELDEFL"
6141 || aKey == "RELATIVEDEFLECTION"
6142 || aKey == "DEVCOEFF"
6143 || aKey == "DEVIATIONCOEFF"
6144 || aKey == "DEVIATIONCOEFFICIENT")
6145 {
6146 aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
6147 aDefParams->SetDeviationCoefficient (aValue.RealValue());
6148 }
6149 else if (aKey == "ANGDEFL"
6150 || aKey == "ANGULARDEFL"
6151 || aKey == "ANGULARDEFLECTION")
6152 {
6153 // currently HLRDeviationAngle is used instead of DeviationAngle in most places
6154 aDefParams->SetHLRAngle (M_PI * aValue.RealValue() / 180.0);
6155 }
6156 else
6157 {
6158 std::cerr << "Warning, unknown argument '" << anArg.ToCString() << "'\n";
6159 }
6160 }
6161
6162 return 0;
6163}
6164
12381341 6165//! Auxiliary method
6166inline void addLight (const Handle(V3d_Light)& theLightNew,
6167 const Standard_Boolean theIsGlobal)
6168{
6169 if (theLightNew.IsNull())
6170 {
6171 return;
6172 }
6173
6174 if (theIsGlobal)
6175 {
6176 ViewerTest::GetViewerFromContext()->SetLightOn (theLightNew);
6177 }
6178 else
6179 {
6180 ViewerTest::CurrentView()->SetLightOn (theLightNew);
6181 }
6182}
6183
6184//! Auxiliary method
6185inline Standard_Integer getLightId (const TCollection_AsciiString& theArgNext)
6186{
6187 TCollection_AsciiString anArgNextCase (theArgNext);
6188 anArgNextCase.UpperCase();
6189 if (anArgNextCase.Length() > 5
6190 && anArgNextCase.SubString (1, 5).IsEqual ("LIGHT"))
6191 {
6192 return theArgNext.SubString (6, theArgNext.Length()).IntegerValue();
6193 }
6194 else
6195 {
6196 return theArgNext.IntegerValue();
6197 }
6198}
6199
6200//===============================================================================================
6201//function : VLight
6202//purpose :
6203//===============================================================================================
6204static int VLight (Draw_Interpretor& theDi,
6205 Standard_Integer theArgsNb,
6206 const char** theArgVec)
6207{
6208 Handle(V3d_View) aView = ViewerTest::CurrentView();
6209 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
6210 if (aView.IsNull()
6211 || aViewer.IsNull())
6212 {
6213 std::cerr << "No active viewer!\n";
6214 return 1;
6215 }
6216
6217 Standard_Real anXYZ[3];
6218 Quantity_Coefficient anAtten[2];
6219 if (theArgsNb < 2)
6220 {
6221 // print lights info
6222 Standard_Integer aLightId = 0;
6223 for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightId)
6224 {
6225 Handle(V3d_Light) aLight = aView->ActiveLight();
6226 const Quantity_Color aColor = aLight->Color();
6227 theDi << "Light" << aLightId << "\n";
6228 switch (aLight->Type())
6229 {
6230 case V3d_AMBIENT:
6231 {
6232 theDi << " Type: Ambient\n";
6233 break;
6234 }
6235 case V3d_DIRECTIONAL:
6236 {
6237 Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLight);
6238 theDi << " Type: Directional\n";
6239 theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
6240 if (!aLightDir.IsNull())
6241 {
6242 aLightDir->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
6243 theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
6244 aLightDir->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
6245 theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
6246 }
6247 break;
6248 }
6249 case V3d_POSITIONAL:
6250 {
6251 Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight)::DownCast (aLight);
6252 theDi << " Type: Positional\n";
6253 theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
6254 if (!aLightPos.IsNull())
6255 {
6256 aLightPos->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
6257 theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
6258 aLightPos->Attenuation (anAtten[0], anAtten[1]);
6259 theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
6260 }
6261 break;
6262 }
6263 case V3d_SPOT:
6264 {
6265 Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight)::DownCast (aLight);
6266 theDi << " Type: Spot\n";
6267 theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
6268 if (!aLightSpot.IsNull())
6269 {
6270 aLightSpot->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
6271 theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
6272 aLightSpot->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
6273 theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
6274 aLightSpot->Attenuation (anAtten[0], anAtten[1]);
6275 theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
6276 theDi << " Angle: " << (aLightSpot->Angle() * 180.0 / M_PI) << "\n";
6277 theDi << " Exponent: " << aLightSpot->Concentration() << "\n";
6278 }
6279 break;
6280 }
6281 default:
6282 {
6283 theDi << " Type: UNKNOWN\n";
6284 break;
6285 }
6286 }
6287 theDi << " Color: " << aColor.Red() << ", " << aColor.Green() << ", " << aColor.Blue() << "\n";
6288 }
6289 }
6290
6291 Handle(V3d_Light) aLightNew;
6292 Handle(V3d_Light) aLightOld;
6293 Standard_Boolean isGlobal = Standard_True;
6294 Standard_Boolean toCreate = Standard_False;
6295 for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
6296 {
6297 Handle(V3d_Light) aLightCurr = aLightNew.IsNull() ? aLightOld : aLightNew;
6298 Handle(V3d_AmbientLight) aLightAmb = Handle(V3d_AmbientLight) ::DownCast (aLightCurr);
6299 Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLightCurr);
6300 Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight) ::DownCast (aLightCurr);
6301 Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight) ::DownCast (aLightCurr);
6302
6303 TCollection_AsciiString aName, aValue;
6304 const TCollection_AsciiString anArg (theArgVec[anArgIt]);
6305 TCollection_AsciiString anArgCase (anArg);
6306 anArgCase.UpperCase();
6307 if (anArgCase.IsEqual ("NEW")
6308 || anArgCase.IsEqual ("ADD")
6309 || anArgCase.IsEqual ("CREATE"))
6310 {
6311 toCreate = Standard_True;
6312 }
6313 else if (anArgCase.IsEqual ("GLOB")
6314 || anArgCase.IsEqual ("GLOBAL"))
6315 {
6316 isGlobal = Standard_True;
6317 }
6318 else if (anArgCase.IsEqual ("LOC")
6319 || anArgCase.IsEqual ("LOCAL"))
6320 {
6321 isGlobal = Standard_False;
6322 }
4fe9ad57 6323 else if (anArgCase.IsEqual ("DEF")
6324 || anArgCase.IsEqual ("DEFAULTS"))
6325 {
6326 toCreate = Standard_False;
6327 aViewer->SetDefaultLights();
6328 }
6329 else if (anArgCase.IsEqual ("CLR")
6330 || anArgCase.IsEqual ("CLEAR"))
6331 {
6332 toCreate = Standard_False;
6333 aView->InitActiveLights();
6334 while (aView->MoreActiveLights())
6335 {
6336 aViewer->DelLight (aView->ActiveLight());
6337 aView->InitActiveLights();
6338 }
6339 }
12381341 6340 else if (anArgCase.IsEqual ("AMB")
6341 || anArgCase.IsEqual ("AMBIENT")
6342 || anArgCase.IsEqual ("AMBLIGHT"))
6343 {
6344 addLight (aLightNew, isGlobal);
6345 if (!toCreate)
6346 {
6347 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6348 return 1;
6349 }
6350 toCreate = Standard_False;
6351 aLightNew = new V3d_AmbientLight (aViewer);
6352 }
6353 else if (anArgCase.IsEqual ("DIRECTIONAL")
6354 || anArgCase.IsEqual ("DIRLIGHT"))
6355 {
6356 addLight (aLightNew, isGlobal);
6357 if (!toCreate)
6358 {
6359 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6360 return 1;
6361 }
6362 toCreate = Standard_False;
6363 aLightNew = new V3d_DirectionalLight (aViewer);
6364 }
6365 else if (anArgCase.IsEqual ("SPOT")
6366 || anArgCase.IsEqual ("SPOTLIGHT"))
6367 {
6368 addLight (aLightNew, isGlobal);
6369 if (!toCreate)
6370 {
6371 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6372 return 1;
6373 }
6374 toCreate = Standard_False;
6375 aLightNew = new V3d_SpotLight (aViewer, 0.0, 0.0, 0.0);
6376 }
6377 else if (anArgCase.IsEqual ("POSLIGHT")
6378 || anArgCase.IsEqual ("POSITIONAL"))
6379 {
6380 addLight (aLightNew, isGlobal);
6381 if (!toCreate)
6382 {
6383 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6384 return 1;
6385 }
6386 toCreate = Standard_False;
6387 aLightNew = new V3d_PositionalLight (aViewer, 0.0, 0.0, 0.0);
6388 }
6389 else if (anArgCase.IsEqual ("CHANGE"))
6390 {
6391 addLight (aLightNew, isGlobal);
6392 aLightNew.Nullify();
6393 if (++anArgIt >= theArgsNb)
6394 {
6395 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6396 return 1;
6397 }
6398
6399 const Standard_Integer aLightId = getLightId (theArgVec[anArgIt]);
6400 Standard_Integer aLightIt = 0;
6401 for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
6402 {
6403 if (aLightIt == aLightId)
6404 {
6405 aLightOld = aView->ActiveLight();
6406 break;
6407 }
6408 }
6409
6410 if (aLightOld.IsNull())
6411 {
6412 std::cerr << "Light " << theArgVec[anArgIt] << " is undefined!\n";
6413 return 1;
6414 }
6415 }
6416 else if (anArgCase.IsEqual ("DEL")
6417 || anArgCase.IsEqual ("DELETE"))
6418 {
6419 Handle(V3d_Light) aLightDel;
6420 if (++anArgIt >= theArgsNb)
6421 {
6422 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6423 return 1;
6424 }
6425
6426 const TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
6427 const Standard_Integer aLightDelId = getLightId (theArgVec[anArgIt]);
6428 Standard_Integer aLightIt = 0;
6429 for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
6430 {
6431 aLightDel = aView->ActiveLight();
6432 if (aLightIt == aLightDelId)
6433 {
6434 break;
6435 }
6436 }
6437 if (!aLightDel.IsNull())
6438 {
6439 aViewer->DelLight (aLightDel);
6440 }
6441 }
6442 else if (anArgCase.IsEqual ("COLOR")
6443 || anArgCase.IsEqual ("COLOUR"))
6444 {
6445 if (++anArgIt >= theArgsNb)
6446 {
6447 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6448 return 1;
6449 }
6450
6451 TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
6452 anArgNext.UpperCase();
6453 const Quantity_Color aColor = ViewerTest::GetColorFromName (anArgNext.ToCString());
6454 if (!aLightCurr.IsNull())
6455 {
6456 aLightCurr->SetColor (aColor);
6457 }
6458 }
6459 else if (anArgCase.IsEqual ("POS")
6460 || anArgCase.IsEqual ("POSITION"))
6461 {
6462 if ((anArgIt + 3) >= theArgsNb)
6463 {
6464 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6465 return 1;
6466 }
6467
6468 anXYZ[0] = Atof (theArgVec[++anArgIt]);
6469 anXYZ[1] = Atof (theArgVec[++anArgIt]);
6470 anXYZ[2] = Atof (theArgVec[++anArgIt]);
6471 if (!aLightDir.IsNull())
6472 {
6473 aLightDir->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
6474 }
6475 else if (!aLightPos.IsNull())
6476 {
6477 aLightPos->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
6478 }
6479 else if (!aLightSpot.IsNull())
6480 {
6481 aLightSpot->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
6482 }
6483 else
6484 {
6485 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6486 return 1;
6487 }
6488 }
6489 else if (anArgCase.IsEqual ("DIR")
6490 || anArgCase.IsEqual ("DIRECTION"))
6491 {
6492 if ((anArgIt + 3) >= theArgsNb)
6493 {
6494 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6495 return 1;
6496 }
6497
6498 anXYZ[0] = Atof (theArgVec[++anArgIt]);
6499 anXYZ[1] = Atof (theArgVec[++anArgIt]);
6500 anXYZ[2] = Atof (theArgVec[++anArgIt]);
6501 if (!aLightDir.IsNull())
6502 {
6503 aLightDir->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
6504 }
6505 else if (!aLightSpot.IsNull())
6506 {
6507 aLightSpot->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
6508 }
6509 else
6510 {
6511 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6512 return 1;
6513 }
6514 }
4fe9ad57 6515 else if (anArgCase.IsEqual ("ANG")
6516 || anArgCase.IsEqual ("ANGLE"))
6517 {
6518 if (++anArgIt >= theArgsNb)
6519 {
6520 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6521 return 1;
6522 }
6523
6524 Standard_Real anAngle = Atof (theArgVec[anArgIt]);
6525
6526 if (!aLightSpot.IsNull())
6527 {
6528 aLightSpot->SetAngle (anAngle / 180.0 * M_PI);
6529 }
6530 }
12381341 6531 else if (anArgCase.IsEqual ("CONSTATTEN")
6532 || anArgCase.IsEqual ("CONSTATTENUATION"))
6533 {
6534 if (++anArgIt >= theArgsNb)
6535 {
6536 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6537 return 1;
6538 }
6539
6540 if (!aLightPos.IsNull())
6541 {
6542 aLightPos->Attenuation (anAtten[0], anAtten[1]);
6543 anAtten[0] = Atof (theArgVec[anArgIt]);
6544 aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
6545 }
6546 else if (!aLightSpot.IsNull())
6547 {
6548 aLightSpot->Attenuation (anAtten[0], anAtten[1]);
6549 anAtten[0] = Atof (theArgVec[anArgIt]);
6550 aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
6551 }
6552 else
6553 {
6554 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6555 return 1;
6556 }
6557 }
6558 else if (anArgCase.IsEqual ("LINATTEN")
6559 || anArgCase.IsEqual ("LINEARATTEN")
6560 || anArgCase.IsEqual ("LINEARATTENUATION"))
6561 {
6562 if (++anArgIt >= theArgsNb)
6563 {
6564 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6565 return 1;
6566 }
6567
6568 if (!aLightPos.IsNull())
6569 {
6570 aLightPos->Attenuation (anAtten[0], anAtten[1]);
6571 anAtten[1] = Atof (theArgVec[anArgIt]);
6572 aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
6573 }
6574 else if (!aLightSpot.IsNull())
6575 {
6576 aLightSpot->Attenuation (anAtten[0], anAtten[1]);
6577 anAtten[1] = Atof (theArgVec[anArgIt]);
6578 aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
6579 }
6580 else
6581 {
6582 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6583 return 1;
6584 }
6585 }
6586 else if (anArgCase.IsEqual ("EXP")
6587 || anArgCase.IsEqual ("EXPONENT")
6588 || anArgCase.IsEqual ("SPOTEXP")
6589 || anArgCase.IsEqual ("SPOTEXPONENT"))
6590 {
6591 if (++anArgIt >= theArgsNb)
6592 {
6593 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6594 return 1;
6595 }
6596
6597 if (!aLightSpot.IsNull())
6598 {
6599 aLightSpot->SetConcentration (Atof (theArgVec[anArgIt]));
6600 }
6601 else
6602 {
6603 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6604 return 1;
6605 }
6606 }
6607 else if (anArgCase.IsEqual ("HEAD")
6608 || anArgCase.IsEqual ("HEADLIGHT"))
6609 {
6610 if (++anArgIt >= theArgsNb)
6611 {
6612 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6613 return 1;
6614 }
6615
6616 if (aLightAmb.IsNull()
6617 && !aLightCurr.IsNull())
6618 {
6619 aLightCurr->SetHeadlight (Draw::Atoi (theArgVec[anArgIt]) != 0);
6620 }
6621 else
6622 {
6623 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
6624 return 1;
6625 }
6626 }
6627 else
6628 {
6629 std::cerr << "Warning: unknown argument '" << anArg << "'\n";
6630 }
6631 }
6632
6633 addLight (aLightNew, isGlobal);
6634 aViewer->UpdateLights();
6635
6636 return 0;
6637}
6638
e276548b 6639//=======================================================================
bc8c79bb 6640//function : VRenderParams
6641//purpose : Enables/disables rendering features
e276548b 6642//=======================================================================
6643
bc8c79bb 6644static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
6645 Standard_Integer theArgNb,
6646 const char** theArgVec)
e276548b 6647{
7ae4a307 6648 Handle(V3d_View) aView = ViewerTest::CurrentView();
6649 if (aView.IsNull())
e276548b 6650 {
bc8c79bb 6651 std::cerr << "Error: no active viewer!\n";
e276548b 6652 return 1;
6653 }
bc8c79bb 6654
6655 Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
6b62b2da 6656 TCollection_AsciiString aCmdName (theArgVec[0]);
6657 aCmdName.LowerCase();
6658 if (aCmdName == "vraytrace")
6659 {
6660 if (theArgNb == 1)
6661 {
6662 theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "on" : "off") << " ";
6663 return 0;
6664 }
6665 else if (theArgNb == 2)
6666 {
6667 TCollection_AsciiString aValue (theArgVec[1]);
6668 aValue.LowerCase();
6669 if (aValue == "on"
6670 || aValue == "1")
6671 {
6672 aParams.Method = Graphic3d_RM_RAYTRACING;
6673 aView->Redraw();
6674 return 0;
6675 }
6676 else if (aValue == "off"
6677 || aValue == "0")
6678 {
6679 aParams.Method = Graphic3d_RM_RASTERIZATION;
6680 aView->Redraw();
6681 return 0;
6682 }
6683 else
6684 {
6685 std::cout << "Error: unknown argument '" << theArgVec[1] << "'\n";
6686 return 1;
6687 }
6688 }
6689 else
6690 {
6691 std::cout << "Error: wrong number of arguments\n";
6692 return 1;
6693 }
6694 }
bc8c79bb 6695
6696 if (theArgNb < 2)
e276548b 6697 {
bc8c79bb 6698 theDI << "renderMode: ";
6699 switch (aParams.Method)
6700 {
6701 case Graphic3d_RM_RASTERIZATION: theDI << "rasterization "; break;
6702 case Graphic3d_RM_RAYTRACING: theDI << "raytrace "; break;
6703 }
6704 theDI << "\n";
8625ef7e 6705 theDI << "fsaa: " << (aParams.IsAntialiasingEnabled ? "on" : "off") << "\n";
6706 theDI << "shadows: " << (aParams.IsShadowEnabled ? "on" : "off") << "\n";
6707 theDI << "reflections: " << (aParams.IsReflectionEnabled ? "on" : "off") << "\n";
6708 theDI << "rayDepth: " << aParams.RaytracingDepth << "\n";
6709 theDI << "gleam: " << (aParams.IsTransparentShadowEnabled ? "on" : "off") << "\n";
6710 theDI << "shadingModel: ";
6711 switch (aView->ShadingModel())
6712 {
6713 case V3d_COLOR: theDI << "color"; break;
6714 case V3d_FLAT: theDI << "flat"; break;
6715 case V3d_GOURAUD: theDI << "gouraud"; break;
6716 case V3d_PHONG: theDI << "phong"; break;
6717 }
6718 theDI << "\n";
bc8c79bb 6719 return 0;
e276548b 6720 }
6721
bc8c79bb 6722 Standard_Boolean toPrint = Standard_False;
8625ef7e 6723 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
e276548b 6724 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
6725 {
bc8c79bb 6726 Standard_CString anArg (theArgVec[anArgIter]);
6727 TCollection_AsciiString aFlag (anArg);
6728 aFlag.LowerCase();
8625ef7e 6729 if (anUpdateTool.parseRedrawMode (aFlag))
6730 {
6731 continue;
6732 }
6733 else if (aFlag == "-echo"
6734 || aFlag == "-print")
e276548b 6735 {
bc8c79bb 6736 toPrint = Standard_True;
8625ef7e 6737 anUpdateTool.Invalidate();
e276548b 6738 }
bc8c79bb 6739 else if (aFlag == "-mode"
6740 || aFlag == "-rendermode"
6741 || aFlag == "-render_mode")
e276548b 6742 {
bc8c79bb 6743 if (toPrint)
6744 {
6745 switch (aParams.Method)
6746 {
6747 case Graphic3d_RM_RASTERIZATION: theDI << "rasterization "; break;
6748 case Graphic3d_RM_RAYTRACING: theDI << "ray-tracing "; break;
6749 }
6750 continue;
6751 }
e276548b 6752 else
bc8c79bb 6753 {
6754 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
6755 return 1;
6756 }
6757 }
6758 else if (aFlag == "-ray"
6759 || aFlag == "-raytrace")
6760 {
6761 if (toPrint)
6762 {
6763 theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "true" : "false") << " ";
6764 continue;
6765 }
6766
6767 aParams.Method = Graphic3d_RM_RAYTRACING;
e276548b 6768 }
bc8c79bb 6769 else if (aFlag == "-rast"
6770 || aFlag == "-raster"
6771 || aFlag == "-rasterization")
e276548b 6772 {
bc8c79bb 6773 if (toPrint)
6774 {
6775 theDI << (aParams.Method == Graphic3d_RM_RASTERIZATION ? "true" : "false") << " ";
6776 continue;
6777 }
6778
6779 aParams.Method = Graphic3d_RM_RASTERIZATION;
6780 }
6781 else if (aFlag == "-raydepth"
6782 || aFlag == "-ray_depth")
6783 {
6784 if (toPrint)
6785 {
6786 theDI << aParams.RaytracingDepth << " ";
6787 continue;
6788 }
6789 else if (++anArgIter >= theArgNb)
6790 {
6791 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
6792 return 1;
6793 }
6794
6795 const Standard_Integer aDepth = Draw::Atoi (theArgVec[anArgIter]);
6796 if (aDepth < 1 || aDepth > 10)
6797 {
6798 std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
6799 return 1;
6800 }
e276548b 6801 else
bc8c79bb 6802 {
6803 aParams.RaytracingDepth = aDepth;
6804 }
6805 }
6806 else if (aFlag == "-shad"
6807 || aFlag == "-shadows")
6808 {
6809 if (toPrint)
6810 {
6811 theDI << (aParams.IsShadowEnabled ? "on" : "off") << " ";
6812 continue;
6813 }
6814
6815 Standard_Boolean toEnable = Standard_True;
6816 if (++anArgIter < theArgNb
6817 && !parseOnOff (theArgVec[anArgIter], toEnable))
6818 {
6819 --anArgIter;
6820 }
6821 aParams.IsShadowEnabled = toEnable;
6822 }
6823 else if (aFlag == "-refl"
6824 || aFlag == "-reflections")
6825 {
6826 if (toPrint)
6827 {
6828 theDI << (aParams.IsReflectionEnabled ? "on" : "off") << " ";
6829 continue;
6830 }
6831
6832 Standard_Boolean toEnable = Standard_True;
6833 if (++anArgIter < theArgNb
6834 && !parseOnOff (theArgVec[anArgIter], toEnable))
6835 {
6836 --anArgIter;
6837 }
6838 aParams.IsReflectionEnabled = toEnable;
6839 }
6840 else if (aFlag == "-fsaa")
6841 {
6842 if (toPrint)
6843 {
6844 theDI << (aParams.IsAntialiasingEnabled ? "on" : "off") << " ";
6845 continue;
6846 }
6847
6848 Standard_Boolean toEnable = Standard_True;
6849 if (++anArgIter < theArgNb
6850 && !parseOnOff (theArgVec[anArgIter], toEnable))
6851 {
6852 --anArgIter;
6853 }
6854 aParams.IsAntialiasingEnabled = toEnable;
6855 }
6856 else if (aFlag == "-gleam")
6857 {
6858 if (toPrint)
6859 {
6860 theDI << (aParams.IsTransparentShadowEnabled ? "on" : "off") << " ";
6861 continue;
6862 }
6863
6864 Standard_Boolean toEnable = Standard_True;
6865 if (++anArgIter < theArgNb
6866 && !parseOnOff (theArgVec[anArgIter], toEnable))
6867 {
6868 --anArgIter;
6869 }
6870 aParams.IsTransparentShadowEnabled = toEnable;
e276548b 6871 }
8625ef7e 6872 else if (aFlag == "-shademodel"
6873 || aFlag == "-shadingmodel"
6874 || aFlag == "-shading")
6875 {
6876 if (toPrint)
6877 {
6878 switch (aView->ShadingModel())
6879 {
6880 case V3d_COLOR: theDI << "color "; break;
6881 case V3d_FLAT: theDI << "flat "; break;
6882 case V3d_GOURAUD: theDI << "gouraud "; break;
6883 case V3d_PHONG: theDI << "phong "; break;
6884 }
6885 continue;
6886 }
6887
6888 if (++anArgIter >= theArgNb)
6889 {
6890 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
6891 }
6892
6893 TCollection_AsciiString aMode (theArgVec[anArgIter]);
6894 aMode.LowerCase();
6895 if (aMode == "color"
6896 || aMode == "none")
6897 {
6898 aView->SetShadingModel (V3d_COLOR);
6899 }
6900 else if (aMode == "flat"
6901 || aMode == "facet")
6902 {
6903 aView->SetShadingModel (V3d_FLAT);
6904 }
6905 else if (aMode == "gouraud"
6906 || aMode == "vertex"
6907 || aMode == "vert")
6908 {
6909 aView->SetShadingModel (V3d_GOURAUD);
6910 }
6911 else if (aMode == "phong"
6912 || aMode == "fragment"
6913 || aMode == "frag"
6914 || aMode == "pixel")
6915 {
6916 aView->SetShadingModel (V3d_PHONG);
6917 }
6918 else
6919 {
6920 std::cout << "Error: unknown shading model '" << aMode << "'\n";
6921 return 1;
6922 }
6923 }
e276548b 6924 else
6925 {
bc8c79bb 6926 std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
6927 return 1;
e276548b 6928 }
6929 }
e276548b 6930 return 0;
6931}
6932
b7cd4ba7 6933//=======================================================================
6934//function : VFrustumCulling
6935//purpose : enables/disables view volume's culling.
6936//=======================================================================
6937static int VFrustumCulling (Draw_Interpretor& theDI,
6938 Standard_Integer theArgNb,
6939 const char** theArgVec)
6940{
6941 Handle(V3d_View) aView = ViewerTest::CurrentView();
6942 if (aView.IsNull())
6943 {
6944 std::cout << theArgVec[0] << " Error: Use 'vinit' command before\n";
6945 return 1;
6946 }
6947
6948 if (theArgNb < 2)
6949 {
6950 theDI << (aView->IsCullingEnabled() ? "on" : "off");
6951 return 0;
6952 }
6953 else if (theArgNb != 2)
6954 {
6955 std::cout << theArgVec[0] << " Syntax error: Specify the mode\n";
6956 return 1;
6957 }
6958
6959 TCollection_AsciiString aModeStr (theArgVec[1]);
6960 aModeStr.LowerCase();
6961 Standard_Boolean toEnable = 0;
6962 if (aModeStr == "on")
6963 {
6964 toEnable = 1;
6965 }
6966 else if (aModeStr == "off")
6967 {
6968 toEnable = 0;
6969 }
6970 else
6971 {
6972 toEnable = Draw::Atoi (theArgVec[1]) != 0;
6973 }
6974
6975 aView->SetFrustumCulling (toEnable);
6976 aView->Redraw();
6977 return 0;
6978}
6979
c398b00e 6980//=======================================================================
6981//function : VHighlightSelected
6982//purpose :
6983//=======================================================================
6984static int VHighlightSelected (Draw_Interpretor& theDI,
6985 Standard_Integer theArgNb,
6986 const char** theArgVec)
6987{
6988 if (ViewerTest::GetAISContext().IsNull())
6989 {
6990 std::cout << theArgVec[0] << " error : Context is not created. Please call vinit before.\n";
6991 return 1;
6992 }
6993
6994 const Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
6995
6996 if (theArgNb < 2)
6997 {
6998 theDI << (aContext->ToHilightSelected() ? "on" : "off");
6999 return 0;
7000 }
7001
7002 if (theArgNb != 2)
7003 {
7004 std::cout << theArgVec[0] << " error : wrong number of parameters."
7005 << "Type 'help" << theArgVec[0] << "' for more information.";
7006 return 1;
7007 }
7008
7009 // Parse parameter
7010 TCollection_AsciiString aMode (theArgVec[1]);
7011 aMode.LowerCase();
7012 Standard_Boolean toEnable = Standard_False;
7013 if (aMode.IsEqual ("on"))
7014 {
7015 toEnable = Standard_True;
7016 }
7017 else if (aMode.IsEqual ("off"))
7018 {
7019 toEnable = Standard_False;
7020 }
7021 else
7022 {
7023 toEnable = Draw::Atoi (theArgVec[1]) != 0;
7024 }
7025
7026 if (toEnable != aContext->ToHilightSelected())
7027 {
7028 aContext->SetToHilightSelected (toEnable);
7029
7030 // Move cursor to null position and back to process updating of detection
7031 // and highlighting of selected object immediatly.
7032 Standard_Integer aPixX = 0;
7033 Standard_Integer aPixY = 0;
7034 const Handle(ViewerTest_EventManager)& anEventManager = ViewerTest::CurrentEventManager();
7035
7036 anEventManager->GetCurrentPosition (aPixX, aPixY);
7037 anEventManager->MoveTo (0, 0);
7038 anEventManager->MoveTo (aPixX, aPixY);
7039 }
7040
7041 return 0;
7042}
7043
0717ddc1 7044//=======================================================================
7045//function : VXRotate
7046//purpose :
7047//=======================================================================
7048static Standard_Integer VXRotate (Draw_Interpretor& di,
7049 Standard_Integer argc,
7050 const char ** argv)
7051{
7052 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
7053 if (aContext.IsNull())
7054 {
7055 di << argv[0] << "ERROR : use 'vinit' command before " << "\n";
7056 return 1;
7057 }
7058
7059 if (argc != 3)
7060 {
7061 di << "ERROR : Usage : " << argv[0] << " name angle" << "\n";
7062 return 1;
7063 }
7064
7065 TCollection_AsciiString aName (argv[1]);
7066 Standard_Real anAngle = Draw::Atof (argv[2]);
7067
7068 // find object
7069 ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
7070 Handle(AIS_InteractiveObject) anIObj;
7071 if (!aMap.IsBound2 (aName) )
7072 {
7073 di << "Use 'vdisplay' before" << "\n";
7074 return 1;
7075 }
7076 else
7077 {
7078 anIObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (aName));
7079
7080 gp_Trsf aTransform;
7081 aTransform.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Vec (1.0, 0.0, 0.0)), anAngle);
7082 aTransform.SetTranslationPart (anIObj->LocalTransformation().TranslationPart());
7083
7084 aContext->SetLocation (anIObj, aTransform);
7085 aContext->UpdateCurrentViewer();
7086 }
7087
7088 return 0;
7089}
7090
7fd59977 7091//=======================================================================
7092//function : ViewerCommands
7093//purpose :
7094//=======================================================================
7095
7096void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
7097{
7098
7099 const char *group = "ZeViewer";
18d715bd 7100 theCommands.Add("vinit",
7101#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
7102 "[name=view_name] [display=display_name] [l=leftPx t=topPx] [w=widthPx h=heightPx]\n"
7103#else
7104 "[name=view_name] [l=leftPx t=topPx] [w=widthPx h=heightPx]\n"
7105#endif
7106 " - Creates new View window with specified name view_name.\n"
7107 "By default the new view is created in the viewer and in"
7108 " graphic driver shared with active view.\n"
7109 " - name = {driverName/viewerName/viewName | viewerName/viewName | viewName}.\n"
7110 "If driverName isn't specified the driver will be shared with active view.\n"
7111 "If viewerName isn't specified the viewer will be shared with active view.\n"
7112#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
7113 " - display = HostName.DisplayNumber[:ScreenNumber] : if specified"
7114 "is used in creation of graphic driver\n"
7115#endif
7116 " - l, t: pixel position of left top corner of the window\n"
7117 " - w,h: width and heigth of window respectively.\n"
7118 "Additional commands for operations with views: vclose, vactivate, vviewlist.\n",
7fd59977 7119 __FILE__,VInit,group);
18d715bd 7120 theCommands.Add("vclose" ,
d0cc1cb7 7121 "[view_id [keep_context=0|1]]\n"
18d715bd 7122 "or vclose ALL - to remove all created views\n"
7123 " - removes view(viewer window) defined by its view_id.\n"
7124 " - keep_context: by default 0; if 1 and the last view is deleted"
7125 " the current context is not removed.",
7126 __FILE__,VClose,group);
7127 theCommands.Add("vactivate" ,
7128 "view_id"
7129 " - activates view(viewer window) defined by its view_id",
7130 __FILE__,VActivate,group);
7131 theCommands.Add("vviewlist",
7132 "vviewlist [format={tree, long}]"
7133 " - prints current list of views per viewer and graphic_driver ID shared between viewers"
7134 " - format: format of result output, if tree the output is a tree view;"
7135 "otherwise it's a list of full view names. By default format = tree",
7136 __FILE__,VViewList,group);
7fd59977 7137 theCommands.Add("vhelp" ,
7138 "vhelp : display help on the viewer commands",
7139 __FILE__,VHelp,group);
7140 theCommands.Add("vtop" ,
44b8f2d6 7141 "vtop or <T> : Top view" ,
7fd59977 7142 __FILE__,VTop,group);
44b8f2d6 7143 theCommands.Add("vbottom" ,
7144 "vbottom : Bottom view" ,
7145 __FILE__,VBottom,group);
7146 theCommands.Add("vleft" ,
7147 "vleft : Left view" ,
7148 __FILE__,VLeft,group);
7149 theCommands.Add("vright" ,
7150 "vright : Right view" ,
7151 __FILE__,VRight,group);
7fd59977 7152 theCommands.Add("vaxo" ,
7153 " vaxo or <A> : Axonometric view ",
7154 __FILE__,VAxo,group);
44b8f2d6 7155 theCommands.Add("vfront" ,
7156 "vfront : Front view" ,
7157 __FILE__,VFront,group);
7158 theCommands.Add("vback" ,
7159 "vback : Back view" ,
7160 __FILE__,VBack,group);
7fd59977 7161 theCommands.Add("vpick" ,
7162 "vpick : vpick X Y Z [shape subshape] ( all variables as string )",
7163 VPick,group);
7164 theCommands.Add("vfit" ,
7165 "vfit or <F> : vfit",
7166 __FILE__,VFit,group);
6262a303 7167 theCommands.Add ("vfitarea",
7168 "vfitarea x1 y1 x2 y2"
7169 "\n\t\t: vfitarea x1 y1 z1 x2 y2 z2"
7170 "\n\t\t: Fit view to show area located between two points"
7171 "\n\t\t: given in world 2D or 3D corrdinates.",
7172 __FILE__, VFitArea, group);
197ac94e 7173 theCommands.Add ("vzfit", "vzfit [scale]\n"
7174 " Matches Z near, Z far view volume planes to the displayed objects.\n"
7175 " \"scale\" - specifies factor to scale computed z range.\n",
7176 __FILE__, VZFit, group);
7fd59977 7177 theCommands.Add("vrepaint",
7178 "vrepaint : vrepaint, force redraw",
7179 __FILE__,VRepaint,group);
7180 theCommands.Add("vclear",
7181 "vclear : vclear",
7182 __FILE__,VClear,group);
7183 theCommands.Add("vsetbg",
7184 "vsetbg : vsetbg imagefile [filltype] : Load image as background",
7185 __FILE__,VSetBg,group);
f8b2ed36 7186 theCommands.Add("vsetbgmode",
7187 "vsetbgmode : vsetbgmode filltype : Change background image fill type",
7188 __FILE__,VSetBgMode,group);
7fd59977 7189 theCommands.Add("vsetgradientbg",
f8b2ed36 7190 "vsetgradientbg : vsetgradientbg r1 g1 b1 r2 g2 b2 filltype : Mount gradient background",
7fd59977 7191 __FILE__,VSetGradientBg,group);
f8b2ed36 7192 theCommands.Add("vsetgrbgmode",
7193 "vsetgrbgmode : vsetgrbgmode filltype : Change gradient background fill type",
7194 __FILE__,VSetGradientBgMode,group);
7195 theCommands.Add("vsetcolorbg",
7196 "vsetcolorbg : vsetcolorbg r g b : Set background color",
7197 __FILE__,VSetColorBg,group);
7fd59977 7198 theCommands.Add("vscale",
7199 "vscale : vscale X Y Z",
7200 __FILE__,VScale,group);
7201 theCommands.Add("vzbufftrihedron",
7c8a8fcc 7202 "vzbufftrihedron [center|left_lower|left_upper|right_lower|right_upper"
7203 " textR=255 textG=255 textB=255 scale=0.1 wireframe|zbuffer]"
7204 " : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron",
7fd59977 7205 __FILE__,VTestZBuffTrihedron,group);
7206 theCommands.Add("vrotate",
7207 "vrotate : vrotate AX AY AZ [X Y Z]",
7208 __FILE__,VRotate,group);
7209 theCommands.Add("vzoom",
7210 "vzoom : vzoom coef",
7211 __FILE__,VZoom,group);
7212 theCommands.Add("vpan",
7213 "vpan : vpan dx dy",
7214 __FILE__,VPan,group);
7215 theCommands.Add("vexport",
5cedc27f
K		 7216 "vexport : vexport full_file_path {PS | EPS | TEX | PDF | SVG | PGF | EMF }"
7217 " : exports the view to a vector file of a given format"
7218 " : notice that EMF format requires patched gl2ps",
7fd59977 7219 __FILE__,VExport,group);
7220 theCommands.Add("vcolorscale",
7221 "vcolorscale : vcolorscale [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = 2 X = 0 Y = 0]: draw color scale",
7222 __FILE__,VColorScale,group);
7223 theCommands.Add("vgraduatedtrihedron",
13a22457 7224 "vgraduatedtrihedron : 1/0 (display/erase) [Xname Yname Zname [Font [isMultibyte]]]",
7fd59977 7225 __FILE__,VGraduatedTrihedron,group);
7edf74fd 7226 theCommands.Add("vprintview" ,
b5ac8292 7227 "vprintview : width height filename [algo=0] [tile_width tile_height] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
7edf74fd 7228 __FILE__,VPrintView,group);
59f45b7c 7229 theCommands.Add("vzlayer",
c5751993 7230 "vzlayer add/del/get/settings/enable/disable [id]\n"
7231 " add - add new z layer to viewer and print its id\n"
7232 " del - del z layer by its id\n"
7233 " get - print sequence of z layers in increasing order of their overlay level\n"
7234 " settings - print status of z layer settings\n"
7235 " enable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n enables given setting for the z layer\n"
7236 " enable (p[ositive]offset/n[egative]offset) \n enables given setting for the z layer\n"
7237 " disable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n disables given setting for the z layer\n"
7238 "\nWhere id is the layer identificator\n"
7239 "\nExamples:\n"
7240 " vzlayer add\n"
7241 " vzlayer enable poffset 1\n"
7242 " vzlayer disable depthtest 1\n"
7243 " vzlayer del 1\n",
59f45b7c 7244 __FILE__,VZLayer,group);
25289ec1 7245 theCommands.Add("voverlaytext",
7246 "voverlaytext : text x y [height] [font_name] [text_color: R G B] [display_type] [background_color: R G B]"
7247 " : height - pixel height of the text (default=10.0)"
7248 " : font_name - name of font (default=courier)"
7249 " : text_color - three values: RedColor GreenColor BlueColor (default = 255.0 255.0 255.0) "
7250 " : display_type = {normal/subtitle/decal/blend}, (default=normal) "
7251 " : background_color - three values: RedColor GreenColor BlueColor (default = 255.0 255.0 255.0), the parameter is defined for subtitle and decal display types ",
7252 __FILE__,VOverlayText,group);
20637bd2 7253 theCommands.Add("vlayerline",
7254 "vlayerline : vlayerline x1 y1 x2 y2 [linewidth=0.5] [linetype=0] [transparency=1.0]",
7255 __FILE__,VLayerLine,group);
2bd4c032 7256 theCommands.Add ("vgrid",
7257 "vgrid [off] [Mode={r|c}] [Type={l|p}] [OriginX OriginY [StepX/StepRadius StepY/DivNb RotAngle]]"
7258 " : Mode - rectangular or circular"
7259 " : Type - lines or points",
7260 __FILE__, VGrid, group);
208e6839 7261 theCommands.Add ("vfps",
7262 "vfps [framesNb=100] : estimate average frame rate for active view",
7263 __FILE__, VFps, group);
58655684 7264 theCommands.Add ("vgldebug",
7265 "vgldebug [{0|1}] : request debug GL context, should be called before vinit\n"
7266 " : this function is implemented only for Windows\n"
7267 " : GL_ARB_debug_output extension should be exported by OpenGL driver!",
7268 __FILE__, VGlDebug, group);
208e6839 7269 theCommands.Add ("vvbo",
58655684 7270 "vvbo [{0|1}] : turn VBO usage On/Off; affects only newly displayed objects",
208e6839 7271 __FILE__, VVbo, group);
b5ac8292 7272 theCommands.Add ("vstereo",
7273 "\nvstereo [{0|1}] : turn stereo usage On/Off; affects only newly displayed objects",
7274 __FILE__, VStereo, group);
a577aaab 7275 theCommands.Add ("vcaps",
8625ef7e 7276 "vcaps [-vbo {0|1}] [-sprites {0|1}] [-ffp {0|1}]"
7277 "\n\t\t: [-softMode {0|1}] [-noupdate|-update]"
7278 "\n\t\t: Modify particular graphic driver options:"
7279 "\n\t\t: FFP - use fixed-function pipeline instead of"
7280 "\n\t\t: built-in GLSL programs"
7281 "\n\t\t: VBO - use Vertex Buffer Object (copy vertex"
7282 "\n\t\t: arrays to GPU memory)"
7283 "\n\t\t: sprite - use textured sprites instead of bitmaps"
7284 "\n\t\t: softMode - use software OpenGL implementation,"
7285 "\n\t\t: should be set BEFORE viewer creation"
7286 "\n\t\t: Unlike vrenderparams, these parameters control alternative"
7287 "\n\t\t: rendering paths producing the same visual result when"
7288 "\n\t\t: possible."
7289 "\n\t\t: Command is intended for testing old hardware compatibility.",
a577aaab 7290 __FILE__, VCaps, group);
f0430952 7291 theCommands.Add ("vmemgpu",
7292 "vmemgpu [f]: print system-dependent GPU memory information if available;"
7293 " with f option returns free memory in bytes",
7294 __FILE__, VMemGpu, group);
85e096c3 7295 theCommands.Add ("vreadpixel",
7296 "vreadpixel xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]"
7297 " : Read pixel value for active view",
7298 __FILE__, VReadPixel, group);
692613e5 7299 theCommands.Add("diffimage",
7300 "diffimage : diffimage imageFile1 imageFile2 toleranceOfColor(0..1) blackWhite(1|0) borderFilter(1|0) [diffImageFile]",
7301 __FILE__, VDiffImage, group);
4754e164 7302 theCommands.Add ("vselect",
7303 "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [shift_selection = 0|1]\n"
7304 "- emulates different types of selection:\n"
7305 "- 1) single click selection\n"
7306 "- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
7307 "- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
7308 "- 4) any of these selections with shift button pressed",
7309 __FILE__, VSelect, group);
7310 theCommands.Add ("vmoveto",
7311 "vmoveto x y"
7312 "- emulates cursor movement to pixel postion (x,y)",
7313 __FILE__, VMoveTo, group);
197ac94e 7314 theCommands.Add ("vviewparams", "vviewparams usage:\n"
7315 "- vviewparams\n"
7316 "- vviewparams [-scale [s]] [-eye [x y z]] [-at [x y z]] [-up [x y z]]\n"
3dfe95cd 7317 " [-proj [x y z]] [-center x y] [-size sx]\n"
197ac94e 7318 "- Gets or sets current view parameters.\n"
7319 "- If called without arguments, all view parameters are printed.\n"
7320 "- The options are:\n"
3dfe95cd 7321 " -scale [s] : prints or sets viewport relative scale.\n"
197ac94e 7322 " -eye [x y z] : prints or sets eye location.\n"
7323 " -at [x y z] : prints or sets center of look.\n"
7324 " -up [x y z] : prints or sets direction of up vector.\n"
7325 " -proj [x y z] : prints or sets direction of look.\n"
3dfe95cd 7326 " -center x y : sets location of center of the screen in pixels.\n"
7327 " -size [sx] : prints viewport projection width and height sizes\n"
7328 " : or changes the size of its maximum dimension.\n",
197ac94e 7329 __FILE__, VViewParams, group);
4754e164 7330 theCommands.Add("vchangeselected",
dc3fe572 7331 "vchangeselected shape"
4754e164 7332 "- adds to shape to selection or remove one from it",
7333 __FILE__, VChangeSelected, group);
7334 theCommands.Add("vzclipping",
7335 "vzclipping [mode] [depth width]\n"
7336 "- mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]\n"
7337 "- gets or sets ZClipping mode, width and depth",
7338 __FILE__,VZClipping,group);
7339 theCommands.Add ("vnbselected",
7340 "vnbselected", __FILE__, VNbSelected, group);
6b62b2da 7341 theCommands.Add ("vcamera",
7342 "vcamera [-ortho] [-projtype]"
7343 "\n\t\t: [-persp]"
7344 "\n\t\t: [-fovy [Angle]] [-distance [Distance]]"
7345 "\n\t\t: [-stereo] [-leftEye] [-rightEye]"
7346 "\n\t\t: [-iod [Distance]] [-iodType [absolute|relative]]"
7347 "\n\t\t: [-zfocus [Value]] [-zfocusType [absolute|relative]]"
7348 "\n\t\t: Manage camera parameters."
7349 "\n\t\t: Prints current value when option called without argument."
7350 "\n\t\t: Orthographic camera:"
7351 "\n\t\t: -ortho activate orthographic projection"
7352 "\n\t\t: Perspective camera:"
7353 "\n\t\t: -persp activate perspective projection (mono)"
7354 "\n\t\t: -fovy field of view in y axis, in degrees"
7355 "\n\t\t: -distance distance of eye from camera center"
7356 "\n\t\t: Stereoscopic camera:"
7357 "\n\t\t: -stereo perspective projection (stereo)"
7358 "\n\t\t: -leftEye perspective projection (left eye)"
7359 "\n\t\t: -rightEye perspective projection (right eye)"
7360 "\n\t\t: -iod intraocular distance value"
7361 "\n\t\t: -iodType distance type, absolute or relative"
7362 "\n\t\t: -zfocus stereographic focus value"
7363 "\n\t\t: -zfocusType focus type, absolute or relative",
7364 __FILE__, VCamera, group);
b5ac8292 7365 theCommands.Add ("vautozfit", "command to enable or disable automatic z-range adjusting\n"
197ac94e 7366 "- vautozfit [on={1|0}] [scale]\n"
7367 " Prints or changes parameters of automatic z-fit mode:\n"
7368 " \"on\" - turns automatic z-fit on or off\n"
7369 " \"scale\" - specifies factor to scale computed z range.\n",
7370 __FILE__, VAutoZFit, group);
b5ac8292 7371 theCommands.Add ("vzrange", "command to manually access znear and zfar values\n"
7372 " vzrange - without parameters shows current values\n"
7373 " vzrange [znear] [zfar] - applies provided values to view",
7374 __FILE__,VZRange, group);
4754e164 7375 theCommands.Add("vantialiasing",
7376 "vantialiasing 1|0",
7377 __FILE__,VAntialiasing,group);
7378 theCommands.Add ("vpurgedisplay",
eb4320f2 7379 "vpurgedisplay"
4754e164 7380 "- removes structures which don't belong to objects displayed in neutral point",
7381 __FILE__, VPurgeDisplay, group);
7382 theCommands.Add("vsetviewsize",
7383 "vsetviewsize size",
7384 __FILE__,VSetViewSize,group);
7385 theCommands.Add("vmoveview",
7386 "vmoveview Dx Dy Dz [Start = 1|0]",
7387 __FILE__,VMoveView,group);
7388 theCommands.Add("vtranslateview",
7389 "vtranslateview Dx Dy Dz [Start = 1|0)]",
7390 __FILE__,VTranslateView,group);
7391 theCommands.Add("vturnview",
7392 "vturnview Ax Ay Az [Start = 1|0]",
7393 __FILE__,VTurnView,group);
269294d6 7394 theCommands.Add("vtextureenv",
7395 "Enables or disables environment mapping in the 3D view, loading the texture from the given standard "
7396 "or user-defined file and optionally applying texture mapping parameters\n"
7397 " Usage:\n"
7398 " vtextureenv off - disables environment mapping\n"
7399 " vtextureenv on {std_texture|texture_file_name} [rep mod flt ss st ts tt rot] - enables environment mapping\n"
7400 " std_texture = (0..7)\n"
7401 " rep = {clamp|repeat}\n"
7402 " mod = {decal|modulate}\n"
7403 " flt = {nearest|bilinear|trilinear}\n"
7404 " ss, st - scale factors for s and t texture coordinates\n"
7405 " ts, tt - translation for s and t texture coordinates\n"
7406 " rot - texture rotation angle in degrees",
7407 __FILE__, VTextureEnv, group);
0a768f56 7408 theCommands.Add("vhlr" ,
e9224045 7409 "is_enabled={on|off} [show_hidden={1|0}]"
0a768f56 7410 " - Hidden line removal algorithm:"
e9224045 7411 " - is_enabled: if is on HLR algorithm is applied\n"
7412 " - show_hidden: if equals to 1, hidden lines are drawn as dotted ones.\n",
0a768f56 7413 __FILE__,VHLR,group);
7414 theCommands.Add("vhlrtype" ,
7415 "algo_type={algo|polyalgo} [shape_1 ... shape_n]"
7416 " - Changes the type of HLR algorithm using for shapes."
7417 " - algo_type: if equals to algo, exact HLR algorithm is applied;\n"
7418 " if equals to polyalgo, polygonal HLR algorithm is applied."
7419 "If shapes are not given HLR algoithm of given type is applied"
7420 " to all shapes in the view\n",
7421 __FILE__,VHLRType,group);
4269bd1b 7422 theCommands.Add("vclipplane", "vclipplane usage: \n"
7423 " maxplanes <view_name> - get plane limit for view.\n"
7424 " create <plane_name> - create new plane.\n"
7425 " delete <plane_name> - delete plane.\n"
7426 " clone <source_plane> <plane_name> - clone the plane definition.\n"
7427 " set/unset <plane_name> object <object list> - set/unset plane for IO.\n"
7428 " set/unset <plane_name> view <view list> - set/unset plane for view.\n"
7429 " change <plane_name> on/off - turn clipping on/off.\n"
7430 " change <plane_name> equation <a> <b> <c> <d> - change plane equation.\n"
7431 " change <plane_name> capping on/off - turn capping on/off.\n"
7432 " change <plane_name> capping color <r> <g> <b> - set color.\n"
7433 " change <plane name> capping texname <texture> - set texture.\n"
7434 " change <plane_name> capping texscale <sx> <sy> - set tex scale.\n"
7435 " change <plane_name> capping texorigin <tx> <ty> - set tex origin.\n"
7436 " change <plane_name> capping texrotate <angle> - set tex rotation.\n"
7437 " change <plane_name> capping hatch on/off/<id> - set hatching mask.\n"
7438 " please use VSetTextureMode command to enable texture rendering in view.\n"
7439 , __FILE__, VClipPlane, group);
7440 theCommands.Add("vsettexturemode", "vsettexturemode view_name mode \n"
7441 " mode can be:\n"
7442 " 0 - no textures enabled in view.\n"
7443 " 1 - only environment textures enabled.\n"
7444 " 2 - all textures enabled.\n"
7445 " this command sets texture details mode for the specified view.\n"
7446 , __FILE__, VSetTextureMode, group);
392ac980 7447 theCommands.Add("vdefaults",
7448 "vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]",
7449 __FILE__, VDefaults, group);
12381341 7450 theCommands.Add("vlight",
816d03ee 7451 "tool to manage light sources, without arguments shows list of lights."
7452 "\n Main commands: "
7453 "\n 'clear' to clear lights"
7454 "\n '{def}aults' to load deafault lights"
7455 "\n 'add' (or 'new') <type> to add any light source"
7456 "\n where <type> is one of {amb}ient|directional|{spot}light|positional"
7457 "\n 'change' <lightId> to edit light source with specified lightId"
7458 "\n\n In addition to 'add' and 'change' commands you can use light parameters:"
7459 "\n {pos}ition X Y Z"
7460 "\n {dir}ection X Y Z (for directional light or for spotlight)"
7461 "\n color colorName"
7462 "\n {head}light 0|1"
7463 "\n {constAtten}uation value"
7464 "\n {linearAtten}uation value"
7465 "\n angle angleDeg"
7466 "\n {spotexp}onent value"
7467 "\n local|global"
7468 "\n\n example: vlight add positional head 1 pos 0 1 1 color red"
7469 "\n example: vlight change 0 direction 0 -1 0 linearAttenuation 0.2",
12381341 7470 __FILE__, VLight, group);
6b62b2da 7471 theCommands.Add("vraytrace",
7472 "vraytrace [0|1]"
7473 "\n\t\t: Turn on/off raytracing renderer."
7474 "\n\t\t: 'vraytrace 0' alias for 'vrenderparams -raster'."
7475 "\n\t\t: 'vraytrace 1' alias for 'vrenderparams -rayTrace'.",
7476 __FILE__, VRenderParams, group);
bc8c79bb 7477 theCommands.Add("vrenderparams",
7478 "\n Manages rendering parameters: "
8625ef7e 7479 "\n '-rayTrace' Enables GPU ray-tracing"
7480 "\n '-raster' Disables GPU ray-tracing"
7481 "\n '-rayDepth 0..10' Defines maximum ray-tracing depth"
7482 "\n '-shadows on|off' Enables/disables shadows rendering"
7483 "\n '-reflections on|off' Enables/disables specular reflections"
7484 "\n '-fsaa on|off' Enables/disables adaptive anti-aliasing"
7485 "\n '-gleam on|off' Enables/disables transparency shadow effects"
7486 "\n '-shadingModel model' Controls shading model from enumeration"
7487 "\n color, flat, gouraud, phong"
7488 "\n Unlike vcaps, these parameters dramatically change visual properties."
7489 "\n Command is intended to control presentation quality depending on"
7490 "\n hardware capabilities and performance.",
bc8c79bb 7491 __FILE__, VRenderParams, group);
b7cd4ba7 7492 theCommands.Add("vfrustumculling",
7493 "vfrustumculling [toEnable]: enables/disables objects clipping",
7494 __FILE__,VFrustumCulling,group);
c398b00e 7495 theCommands.Add("vhighlightselected",
7496 "vhighlightselected [0|1] or vhighlightselected [on|off]: enables/disables highlighting of selected objects.\n"
7497 "Without arguments it shows if highlighting of selected objects is enabled now.",
7498 __FILE__,VHighlightSelected,group);
7499
0717ddc1 7500
7501 theCommands.Add("vxrotate",
7502 "vxrotate",
7503 __FILE__,VXRotate,group);
7504
7fd59977 7505}
Open CASCADE Technology repository