projects / occt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
0025483: Visualization, TKOpenGl - fix memory leak due to unused stack in OpenGl_Stat...
[occt.git] / src / ViewerTest / ViewerTest_ViewerCommands.cxx
... / ...
CommitLineData
1// Created on: 1998-09-01
2// Created by: Robert COUBLANC
3// Copyright (c) 1998-1999 Matra Datavision
4// Copyright (c) 1999-2014 OPEN CASCADE SAS
5//
6// This file is part of Open CASCADE Technology software library.
7//
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
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.
13//
14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
16
17#include <OpenGl_GlCore20.hxx>
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>
24#include <Graphic3d_AspectMarker3d.hxx>
25#include <Graphic3d_ExportFormat.hxx>
26#include <Graphic3d_NameOfTextureEnv.hxx>
27#include <Graphic3d_TextureEnv.hxx>
28#include <Graphic3d_TextureParams.hxx>
29#include <Graphic3d_TypeOfTextureFilter.hxx>
30#include <Graphic3d_AspectFillArea3d.hxx>
31#include <ViewerTest.hxx>
32#include <ViewerTest_AutoUpdater.hxx>
33#include <ViewerTest_EventManager.hxx>
34#include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
35#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
36#include <Visual3d_View.hxx>
37#include <Visual3d_ViewManager.hxx>
38#include <V3d_AmbientLight.hxx>
39#include <V3d_DirectionalLight.hxx>
40#include <V3d_LayerMgr.hxx>
41#include <V3d_LayerMgrPointer.hxx>
42#include <V3d_PositionalLight.hxx>
43#include <V3d_SpotLight.hxx>
44#include <NCollection_DoubleMap.hxx>
45#include <NCollection_List.hxx>
46#include <NCollection_Vector.hxx>
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>
54#include <Aspect_PrintAlgo.hxx>
55#include <Image_AlienPixMap.hxx>
56#include <OpenGl_GraphicDriver.hxx>
57#include <OSD_Timer.hxx>
58#include <TColStd_HSequenceOfAsciiString.hxx>
59#include <TColStd_SequenceOfInteger.hxx>
60#include <TColStd_HSequenceOfReal.hxx>
61#include <TColgp_Array1OfPnt2d.hxx>
62#include <TColStd_MapOfAsciiString.hxx>
63#include <Visual3d_LayerItem.hxx>
64#include <Aspect_TypeOfLine.hxx>
65#include <Image_Diff.hxx>
66#include <Aspect_DisplayConnection.hxx>
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>
75
76#ifdef WNT
77#undef DrawText
78#endif
79
80#include <Visual3d_Layer.hxx>
81#include <cstdlib>
82
83#if defined(_WIN32)
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)
92 #include <Cocoa_Window.hxx>
93#else
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>
98#endif
99
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
120// Auxiliary definitions
121static const char THE_KEY_DELETE = 127;
122
123//==============================================================================
124// VIEWER GLOBAL VARIABLES
125//==============================================================================
126
127Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
128Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
129
130Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
131extern const Handle(NIS_InteractiveContext)& TheNISContext();
132extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
133
134extern int VErase (Draw_Interpretor& theDI,
135 Standard_Integer theArgNb,
136 const char** theArgVec);
137
138#if defined(_WIN32)
139static Handle(WNT_Window)& VT_GetWindow() {
140 static Handle(WNT_Window) WNTWin;
141 return WNTWin;
142}
143#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
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);
150extern void SetCocoaWindowTitle (const Handle(Cocoa_Window)& theWindow, Standard_CString theTitle);
151extern void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight);
152
153#else
154static Handle(Xw_Window)& VT_GetWindow(){
155 static Handle(Xw_Window) XWWin;
156 return XWWin;
157}
158
159static void VProcessEvents(ClientData,int);
160#endif
161
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
173#if defined(_WIN32) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
174Aspect_Handle GetWindowHandle(const Handle(Aspect_Window)& theWindow)
175{
176 Aspect_Handle aWindowHandle = (Aspect_Handle)NULL;
177#if defined(_WIN32)
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;
187}
188#endif
189
190static Standard_Boolean MyHLRIsOn = Standard_False;
191
192NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
193static NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)> ViewerTest_myContexts;
194static NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)> ViewerTest_myDrivers;
195static OpenGl_Caps ViewerTest_myDefaultCaps;
196
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;
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;
212Standard_Boolean DragFirst = Standard_False;
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;
238#if defined(_WIN32)
239 if (theWClass.IsNull())
240 {
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
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{
438#if defined(_WIN32)
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}
500//==============================================================================
501//function : ViewerInit
502//purpose : Create the window viewer and initialize all the global variable
503//==============================================================================
504
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)
511{
512 // Default position and dimension of the viewer window.
513 // Note that left top corner is set to be sufficiently small to have
514 // window fit in the small screens (actual for remote desktops, see #23003).
515 // The position corresponds to the window's client area, thus some
516 // gap is added for window frame to be visible.
517 Standard_Integer aPxLeft = 20;
518 Standard_Integer aPxTop = 40;
519 Standard_Integer aPxWidth = 409;
520 Standard_Integer aPxHeight = 409;
521 Standard_Boolean toCreateViewer = Standard_False;
522
523 Handle(OpenGl_GraphicDriver) aGraphicDriver;
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)
535 aPxHeight = thePxHeight;
536
537 // Get graphic driver (create it or get from another view)
538 if (!ViewerTest_myDrivers.IsBound1 (aViewNames.GetDriverName()))
539 {
540 // Get connection string
541 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
542 TCollection_AsciiString aDisplayName(theDisplayName);
543 if (!aDisplayName.IsEmpty())
544 SetDisplayConnection (new Aspect_DisplayConnection ());
545 else
546 SetDisplayConnection (new Aspect_DisplayConnection (aDisplayName));
547 #else
548 (void)theDisplayName; // avoid warning on unused argument
549 SetDisplayConnection (new Aspect_DisplayConnection ());
550 #endif
551 aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
552 aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
553 ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
554 toCreateViewer = Standard_True;
555 }
556 else
557 {
558 aGraphicDriver = Handle(OpenGl_GraphicDriver)::DownCast (ViewerTest_myDrivers.Find1 (aViewNames.GetDriverName()));
559 }
560
561 //Dispose the window if input parameters are default
562 if (!ViewerTest_myViews.IsEmpty() && thePxLeft == 0 && thePxTop == 0)
563 {
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("");
586
587 while (IsWindowOverlapped (aPxLeft, aPxTop, aPxLeft + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId))
588 {
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;
605 }
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
622 Handle(V3d_Viewer) a3DViewer;
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();
631 }
632 else if (ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName()))
633 {
634 ViewerTest::SetAISContext(ViewerTest_myContexts.Find1(aViewNames.GetViewerName()));
635 a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
636 }
637 else if (a3DViewer.IsNull())
638 {
639 toCreateViewer = Standard_True;
640 TCollection_ExtendedString NameOfWindow("Viewer3D");
641 a3DViewer = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
642
643 NameOfWindow = TCollection_ExtendedString("Collector");
644
645 a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
646 }
647
648 // AIS context setup
649 if (ViewerTest::GetAISContext().IsNull() ||
650 !(ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName())))
651 {
652 Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (a3DViewer);
653 ViewerTest::SetAISContext (aContext);
654 ViewerTest_myContexts.Bind (aViewNames.GetViewerName(), ViewerTest::GetAISContext());
655 }
656 else
657 {
658 ViewerTest::ResetEventManager();
659 }
660
661 // Create window
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);
669#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
670 VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
671 aPxLeft, aPxTop,
672 aPxWidth, aPxHeight);
673 ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
674#else
675 VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
676 aTitle.ToCString(),
677 aPxLeft, aPxTop,
678 aPxWidth, aPxHeight);
679#endif
680 VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
681
682 // NIS setup
683 Handle(NIS_View) aView = new NIS_View (a3DViewer, VT_GetWindow());
684
685 ViewerTest::CurrentView(aView);
686 ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
687 TheNISContext()->AttachView (aView);
688
689 // Setup for X11 or NT
690 OSWindowSetup();
691
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.);
698
699 a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
700 if (toCreateViewer)
701 {
702 a3DViewer->SetDefaultLights();
703 a3DViewer->SetLightOn();
704 }
705
706 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
707 #if TCL_MAJOR_VERSION < 8
708 Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
709 TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
710 #else
711 Tk_CreateFileHandler(XConnectionNumber(GetDisplayConnection()->GetDisplay()),
712 TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
713 #endif
714 #endif
715
716 VT_GetWindow()->Map();
717
718 // Set the handle of created view in the event manager
719 ViewerTest::ResetEventManager();
720
721 ViewerTest::CurrentView()->Redraw();
722
723 aView.Nullify();
724 a3DViewer.Nullify();
725
726 return aViewNames.GetViewName();
727}
728
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
743//==============================================================================
744//function : Vinit
745//purpose : Create the window viewer and initialize all the global variable
746// Use Tk_CreateFileHandler on UNIX to catch the X11 Viewer event
747//==============================================================================
748
749static int VInit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
750{
751 if (theArgsNb > 9)
752 {
753 std::cerr << theArgVec[0] << ": incorrect number of command arguments.\n"
754 << "Type help for more information.\n";
755 return 1;
756 }
757
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)
762 {
763 const TCollection_AsciiString anArg = theArgVec[anArgIt];
764 TCollection_AsciiString anArgCase = anArg;
765 anArgCase.UpperCase();
766 if (ViewerTest::SplitParameter (anArg, aName, aValue))
767 {
768 aName.UpperCase();
769 if (aName.IsEqual ("NAME"))
770 {
771 aViewName = aValue;
772 }
773 else if (aName.IsEqual ("L")
774 || aName.IsEqual ("LEFT"))
775 {
776 aPxLeft = aValue.IntegerValue();
777 }
778 else if (aName.IsEqual ("T")
779 || aName.IsEqual ("TOP"))
780 {
781 aPxTop = aValue.IntegerValue();
782 }
783 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
784 else if (aName.IsEqual ("DISP")
785 || aName.IsEqual ("DISPLAY"))
786 {
787 aDisplayName = aValue;
788 }
789 #endif
790 else if (aName.IsEqual ("W")
791 || aName.IsEqual ("WIDTH"))
792 {
793 aPxWidth = aValue.IntegerValue();
794 }
795 else if (aName.IsEqual ("H")
796 || aName.IsEqual ("HEIGHT"))
797 {
798 aPxHeight = aValue.IntegerValue();
799 }
800 else
801 {
802 std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
803 }
804 }
805 else if (aViewName.IsEmpty())
806 {
807 aViewName = anArg;
808 }
809 else
810 {
811 std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
812 }
813 }
814
815 ViewerTest_Names aViewNames (aViewName);
816 if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
817 {
818 TCollection_AsciiString aCommand = TCollection_AsciiString ("vactivate ") + aViewNames.GetViewName();
819 theDi.Eval (aCommand.ToCString());
820 return 0;
821 }
822
823 TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight,
824 aViewName.ToCString(),
825 aDisplayName.ToCString());
826 theDi << aViewId;
827 return 0;
828}
829
830//==============================================================================
831//function : VHLR
832//purpose : hidden lines removal algorithm
833//draw args: vhlr is_enabled={on|off} [show_hidden={1|0}]
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
844 if (argc < 2)
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
851 // Enable or disable HLR mode.
852 Standard_Boolean isHLROn =
853 (!strcasecmp (argv[1], "on")) ? Standard_True : Standard_False;
854
855 if (isHLROn != MyHLRIsOn)
856 {
857 MyHLRIsOn = isHLROn;
858 ViewerTest::CurrentView()->SetComputedMode (MyHLRIsOn);
859 }
860
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 }
898
899 ViewerTest::CurrentView()->Update();
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
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
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
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
1149static int VClose (Draw_Interpretor& /*theDi*/,
1150 Standard_Integer theArgsNb,
1151 const char** theArgVec)
1152{
1153 NCollection_List<TCollection_AsciiString> aViewList;
1154 if (theArgsNb > 1)
1155 {
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
1173 {
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());
1181 }
1182 }
1183 else
1184 {
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()));
1192 }
1193
1194 Standard_Boolean toRemoveContext = (theArgsNb != 3 || Draw::Atoi (theArgVec[2]) != 1);
1195 for (NCollection_List<TCollection_AsciiString>::Iterator anIter(aViewList);
1196 anIter.More(); anIter.Next())
1197 {
1198 ViewerTest::RemoveView (anIter.Value(), toRemoveContext);
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]);
1224 if ( strcasecmp( aNameString.ToCString(), "NONE" ) == 0 )
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"
1275 << "Usage: " << theArgVec[0] << " name";
1276 return 1;
1277 }
1278 if (ViewerTest_myContexts.Size() < 1)
1279 return 0;
1280
1281 Standard_Boolean isTreeView =
1282 (( theArgsNb==1 ) || ( strcasecmp( theArgVec[1], "long" ) != 0 ));
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
1329//==============================================================================
1330//function : VT_ProcessKeyPress
1331//purpose : Handle KeyPress event from a CString
1332//==============================================================================
1333void VT_ProcessKeyPress (const char* buf_ret)
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
1340 if (!strcasecmp (buf_ret, "A"))
1341 {
1342 // AXO
1343 aView->SetProj(V3d_XposYnegZpos);
1344 }
1345 else if (!strcasecmp (buf_ret, "D"))
1346 {
1347 // Reset
1348 aView->Reset();
1349 }
1350 else if (!strcasecmp (buf_ret, "F"))
1351 {
1352 // FitAll
1353 if (aNisView.IsNull())
1354 aView->FitAll();
1355 else
1356 aNisView->FitAll3d();
1357 }
1358 else if (!strcasecmp (buf_ret, "H"))
1359 {
1360 // HLR
1361 cout << "HLR" << endl;
1362 aView->SetComputedMode (!aView->ComputedMode());
1363 MyHLRIsOn = aView->ComputedMode();
1364 }
1365 else if (!strcasecmp (buf_ret, "P"))
1366 {
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();
1406
1407 }
1408 else if (!strcasecmp (buf_ret, "S"))
1409 {
1410 std::cout << "setup Shaded display mode" << std::endl;
1411
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 }
1428 else if (!strcasecmp (buf_ret, "U"))
1429 {
1430 // Unset display mode
1431 std::cout << "reset display mode to defaults" << std::endl;
1432
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 }
1450 else if (!strcasecmp (buf_ret, "T"))
1451 {
1452 // Top
1453 aView->SetProj(V3d_Zpos);
1454 }
1455 else if (!strcasecmp (buf_ret, "B"))
1456 {
1457 // Bottom
1458 aView->SetProj(V3d_Zneg);
1459 }
1460 else if (!strcasecmp (buf_ret, "L"))
1461 {
1462 // Left
1463 aView->SetProj(V3d_Xneg);
1464 }
1465 else if (!strcasecmp (buf_ret, "R"))
1466 {
1467 // Right
1468 aView->SetProj(V3d_Xpos);
1469 }
1470 else if (!strcasecmp (buf_ret, "W"))
1471 {
1472 std::cout << "setup WireFrame display mode" << std::endl;
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 }
1489 else if (!strcasecmp (buf_ret, "Z"))
1490 {
1491 // ZCLIP
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 }
1507 else if (!strcasecmp (buf_ret, ","))
1508 {
1509 ViewerTest::GetAISContext()->HilightNextDetected(ViewerTest::CurrentView());
1510 }
1511 else if (!strcasecmp (buf_ret, "."))
1512 {
1513 ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
1514 }
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
1528 Standard_Integer Num = Draw::Atoi(buf_ret);
1529 if(Num>=0 && Num<=7)
1530 ViewerTest::StandardModeActivation(Num);
1531 }
1532}
1533
1534//==============================================================================
1535//function : VT_ProcessExpose
1536//purpose : Redraw the View on an Expose Event
1537//==============================================================================
1538void VT_ProcessExpose()
1539{
1540 Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1541 if (!aView3d.IsNull())
1542 {
1543 aView3d->Redraw();
1544 }
1545}
1546
1547//==============================================================================
1548//function : VT_ProcessConfigure
1549//purpose : Resize the View on an Configure Event
1550//==============================================================================
1551void VT_ProcessConfigure()
1552{
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();
1562}
1563
1564//==============================================================================
1565//function : VT_ProcessButton1Press
1566//purpose : Picking
1567//==============================================================================
1568Standard_Boolean VT_ProcessButton1Press (Standard_Integer ,
1569 const char** theArgVec,
1570 Standard_Boolean theToPick,
1571 Standard_Boolean theIsShift)
1572{
1573 if (theToPick)
1574 {
1575 Standard_Real X, Y, Z;
1576 ViewerTest::CurrentView()->Convert (X_Motion, Y_Motion, X, Y, Z);
1577
1578 Draw::Set (theArgVec[1], X);
1579 Draw::Set (theArgVec[2], Y);
1580 Draw::Set (theArgVec[3], Z);
1581 }
1582
1583 if (theIsShift)
1584 {
1585 ViewerTest::CurrentEventManager()->ShiftSelect();
1586 }
1587 else
1588 {
1589 ViewerTest::CurrentEventManager()->Select();
1590 }
1591
1592 return Standard_False;
1593}
1594
1595//==============================================================================
1596//function : VT_ProcessButton1Release
1597//purpose : End selecting
1598//==============================================================================
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}
1617
1618//==============================================================================
1619//function : VT_ProcessButton3Press
1620//purpose : Start Rotation
1621//==============================================================================
1622void VT_ProcessButton3Press()
1623{
1624 Start_Rot = 1;
1625 if (MyHLRIsOn)
1626 {
1627 ViewerTest::CurrentView()->SetComputedMode (Standard_False);
1628 }
1629 ViewerTest::CurrentView()->StartRotation( X_ButtonPress, Y_ButtonPress );
1630}
1631
1632//==============================================================================
1633//function : VT_ProcessButton3Release
1634//purpose : End rotation
1635//==============================================================================
1636void VT_ProcessButton3Release()
1637{
1638 if (Start_Rot)
1639 {
1640 Start_Rot = 0;
1641 if (MyHLRIsOn)
1642 {
1643 ViewerTest::CurrentView()->SetComputedMode (Standard_True);
1644 }
1645 }
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
1693#if defined(_WIN32) || ! defined(__APPLE__) || defined(MACOSX_USE_GLX)
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}
1701#endif
1702
1703//==============================================================================
1704//function : VT_ProcessControlButton2Motion
1705//purpose : Panning
1706//==============================================================================
1707void VT_ProcessControlButton2Motion()
1708{
1709 Standard_Integer aDx = X_Motion - X_ButtonPress;
1710 Standard_Integer aDy = Y_Motion - Y_ButtonPress;
1711
1712 aDy = -aDy; // Xwindow Y axis is from top to Bottom
1713
1714 ViewerTest::CurrentView()->Pan (aDx, aDy);
1715
1716 X_ButtonPress = X_Motion;
1717 Y_ButtonPress = Y_Motion;
1718}
1719
1720//==============================================================================
1721//function : VT_ProcessControlButton3Motion
1722//purpose : Rotation
1723//==============================================================================
1724void VT_ProcessControlButton3Motion()
1725{
1726 if (Start_Rot)
1727 {
1728 ViewerTest::CurrentView()->Rotation (X_Motion, Y_Motion);
1729 }
1730}
1731
1732//==============================================================================
1733//function : VT_ProcessMotion
1734//purpose :
1735//==============================================================================
1736void VT_ProcessMotion()
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
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{
1757 if ( ViewerTest::CurrentView().IsNull() )
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
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** )
1774{
1775 return ViewProject(di, V3d_XposYnegZpos);
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{
1786 return ViewProject(di, V3d_Zpos);
1787}
1788
1789//==============================================================================
1790//function : VBottom
1791//purpose : Switch to a Bottom View
1792//Draw arg : No args
1793//==============================================================================
1794
1795static int VBottom(Draw_Interpretor& di, Standard_Integer , const char** )
1796{
1797 return ViewProject(di, V3d_Zneg);
1798}
1799
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}
1821
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);
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";
1858 di << "B : BottomView" << "\n";
1859 di << "R : RightView" << "\n";
1860 di << "L : LeftView" << "\n";
1861 di << "A : AxonometricView" << "\n";
1862 di << "D : ResetView" << "\n";
1863
1864 di << "========================="<<"\n";
1865 di << "S : Shading" << "\n";
1866 di << "W : Wireframe" << "\n";
1867 di << "H : HidelLineRemoval" << "\n";
1868 di << "U : Unset display mode" << "\n";
1869 di << "Delete : Remove selection from viewer" << "\n";
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
1882 di << "========================="<<"\n";
1883 di << "Z : Switch Z clipping On/Off" << "\n";
1884 di << ", : Hilight next detected" << "\n";
1885 di << ". : Hilight previous detected" << "\n";
1886
1887 return 0;
1888}
1889
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{
1902 if (!ViewerTest_myViews.IsEmpty()) {
1903
1904 WPARAM fwKeys = wParam;
1905
1906 switch( Msg ) {
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;
1925 case WM_LBUTTONUP:
1926 if (!DragFirst)
1927 {
1928 HDC hdc = GetDC( hwnd );
1929 SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
1930 SetROP2( hdc, R2_NOT );
1931 Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
1932 ReleaseDC( hwnd, hdc );
1933 VT_ProcessButton1Release (fwKeys & MK_SHIFT);
1934 }
1935 IsDragged = Standard_False;
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;
1943 X_ButtonPress = LOWORD(lParam);
1944 Y_ButtonPress = HIWORD(lParam);
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 )
1960 Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
1961
1962 DragFirst = Standard_False;
1963 X_Motion = LOWORD(lParam);
1964 Y_Motion = HIWORD(lParam);
1965
1966 Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
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{
1990 static int Up = 1;
1991
1992 if ( !ViewerTest::CurrentView().IsNull() ) {
1993 PAINTSTRUCT ps;
1994
1995 switch( Msg ) {
1996 case WM_PAINT:
1997 BeginPaint(hwnd, &ps);
1998 EndPaint(hwnd, &ps);
1999 VT_ProcessExpose();
2000 break;
2001
2002 case WM_SIZE:
2003 VT_ProcessConfigure();
2004 break;
2005
2006 case WM_KEYDOWN:
2007 if ((wParam != VK_SHIFT) && (wParam != VK_CONTROL))
2008 {
2009 char c[2];
2010 c[0] = (char) wParam;
2011 c[1] = '\0';
2012 if (wParam == VK_DELETE)
2013 {
2014 c[0] = THE_KEY_DELETE;
2015 }
2016 VT_ProcessKeyPress (c);
2017 }
2018 break;
2019
2020 case WM_LBUTTONUP:
2021 case WM_MBUTTONUP:
2022 case WM_RBUTTONUP:
2023 Up = 1;
2024 VT_ProcessButton3Release();
2025 break;
2026
2027 case WM_LBUTTONDOWN:
2028 case WM_MBUTTONDOWN:
2029 case WM_RBUTTONDOWN:
2030 {
2031 WPARAM fwKeys = wParam;
2032
2033 Up = 0;
2034
2035 X_ButtonPress = LOWORD(lParam);
2036 Y_ButtonPress = HIWORD(lParam);
2037
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 }
2048 }
2049 else if (Msg == WM_RBUTTONDOWN)
2050 {
2051 // Start rotation
2052 VT_ProcessButton3Press();
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
2072 VT_ProcessButton3Press();
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) ) ){
2083 VT_ProcessControlButton2Motion();
2084 }
2085 else if ( fwKeys & MK_RBUTTON ) {
2086 VT_ProcessControlButton3Motion();
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
2099 else if (GetWindowHandle (VT_GetWindow()) == hwnd)
2100 {
2101 if ((fwKeys & MK_MBUTTON
2102 || ((fwKeys & MK_LBUTTON) && (fwKeys & MK_RBUTTON))))
2103 {
2104 ProcessZClipMotion();
2105 }
2106 else
2107 {
2108 VT_ProcessMotion();
2109 }
2110 }
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
2132int ViewerMainLoop(Standard_Integer argc, const char** argv)
2133{
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
2144 while ( Ppick == 1 ) {
2145 // Wait for a VT_ProcessButton1Press() to toggle pick to 1 or 0
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
2158#elif !defined(__APPLE__) || defined(MACOSX_USE_GLX)
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
2178{
2179 static XEvent aReport;
2180 Standard_Boolean pick = argc > 0;
2181 Display *aDisplay = GetDisplayConnection()->GetDisplay();
2182 XNextEvent (aDisplay, &aReport);
2183
2184 // Handle event for the chosen display connection
2185 switch (aReport.type) {
2186 case ClientMessage:
2187 {
2188 if((Atom)aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
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;
2205 case Expose:
2206 {
2207 VT_ProcessExpose();
2208 }
2209 break;
2210 case ConfigureNotify:
2211 {
2212 VT_ProcessConfigure();
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
2223 ret_len = XLookupString( ( XKeyEvent *)&aReport ,
2224 (char *) buf_ret , 10 ,
2225 &ks_ret , &status_in_out ) ;
2226
2227
2228 buf_ret[ret_len] = '\0' ;
2229
2230 if (ret_len)
2231 {
2232 VT_ProcessKeyPress (buf_ret);
2233 }
2234 }
2235 break;
2236 case ButtonPress:
2237 {
2238 X_ButtonPress = aReport.xbutton.x;
2239 Y_ButtonPress = aReport.xbutton.y;
2240
2241 if (aReport.xbutton.button == Button1)
2242 {
2243 if (aReport.xbutton.state & ControlMask)
2244 {
2245 pick = VT_ProcessButton1Press (argc, argv, pick, (aReport.xbutton.state & ShiftMask));
2246 }
2247 else
2248 {
2249 IsDragged = Standard_True;
2250 DragFirst = Standard_True;
2251 }
2252 }
2253 else if (aReport.xbutton.button == Button3)
2254 {
2255 // Start rotation
2256 VT_ProcessButton3Press();
2257 }
2258 }
2259 break;
2260 case ButtonRelease:
2261 {
2262 if( IsDragged )
2263 {
2264 if( !DragFirst )
2265 {
2266 Aspect_Handle aWindow = VT_GetWindow()->XWindow();
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 ) );
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
2278 Standard_Boolean ShiftPressed = ( aReport.xbutton.state & ShiftMask );
2279 if( aReport.xbutton.button==1 )
2280 if( DragFirst )
2281 if( ShiftPressed )
2282 {
2283 aContext->ShiftSelect();
2284 }
2285 else
2286 {
2287 aContext->Select();
2288 }
2289 else
2290 if( ShiftPressed )
2291 {
2292 aContext->ShiftSelect( min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ),
2293 max( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
2294 ViewerTest::CurrentView());
2295 }
2296 else
2297 {
2298 aContext->Select( min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ),
2299 max( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
2300 ViewerTest::CurrentView() );
2301 }
2302 else
2303 VT_ProcessButton3Release();
2304
2305 IsDragged = Standard_False;
2306 }
2307 else
2308 VT_ProcessButton3Release();
2309 }
2310 break;
2311 case MotionNotify:
2312 {
2313 if (GetWindowHandle (VT_GetWindow()) != aReport.xmotion.window)
2314 {
2315 break;
2316 }
2317 if( IsDragged )
2318 {
2319 Aspect_Handle aWindow = VT_GetWindow()->XWindow();
2320 GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
2321 XSetFunction( aDisplay, gc, GXinvert );
2322
2323 if( !DragFirst )
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 ) );
2325
2326 X_Motion = aReport.xmotion.x;
2327 Y_Motion = aReport.xmotion.y;
2328 DragFirst = Standard_False;
2329
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 ) );
2331 }
2332 else
2333 {
2334 X_Motion = aReport.xmotion.x;
2335 Y_Motion = aReport.xmotion.y;
2336
2337 // remove all the ButtonMotionMaskr
2338 while( XCheckMaskEvent( aDisplay, ButtonMotionMask, &aReport) ) ;
2339
2340 if ( ZClipIsOn && aReport.xmotion.state & ShiftMask ) {
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
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
2360 ViewerTest::CurrentView()->Redraw();
2361 }
2362 }
2363
2364 if ( aReport.xmotion.state & ControlMask ) {
2365 if ( aReport.xmotion.state & Button1Mask ) {
2366 ProcessControlButton1Motion();
2367 }
2368 else if ( aReport.xmotion.state & Button2Mask ) {
2369 VT_ProcessControlButton2Motion();
2370 }
2371 else if ( aReport.xmotion.state & Button3Mask ) {
2372 VT_ProcessControlButton3Motion();
2373 }
2374 }
2375 else
2376 {
2377 VT_ProcessMotion();
2378 }
2379 }
2380 }
2381 break;
2382}
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{
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()));
2400 }
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 {
2406 for (int i = 0; i < anEventNumbers.Value(anEventIter) &&
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 }
2415 }
2416
2417 SetDisplayConnection (ViewerTest::GetAISContext()->CurrentViewer()->Driver()->GetDisplayConnection());
2418
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{
2430#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
2431 // X11
2432
2433 Window window = VT_GetWindow()->XWindow();
2434 SetDisplayConnection (ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
2435 Display *aDisplay = GetDisplayConnection()->GetDisplay();
2436 XSynchronize(aDisplay, 1);
2437
2438 // X11 : For keyboard on SUN
2439 XWMHints wmhints;
2440 wmhints.flags = InputHint;
2441 wmhints.input = 1;
2442
2443 XSetWMHints( aDisplay, window, &wmhints);
2444
2445 XSelectInput( aDisplay, window, ExposureMask | KeyPressMask |
2446 ButtonPressMask | ButtonReleaseMask |
2447 StructureNotifyMask |
2448 PointerMotionMask |
2449 Button1MotionMask | Button2MotionMask |
2450 Button3MotionMask | FocusChangeMask
2451 );
2452 Atom aDeleteWindowAtom = GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW);
2453 XSetWMProtocols(aDisplay, window, &aDeleteWindowAtom, 1);
2454
2455 XSynchronize(aDisplay, 0);
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
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
2545//==============================================================================
2546//function : VZFit
2547//purpose : ZFitall, no DRAW arguments
2548//Draw arg : No args
2549//==============================================================================
2550static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
2551{
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 {
2562 aCurrentView->View()->ZFitAll();
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
2574 aCurrentView->View()->ZFitAll (aScale);
2575 aCurrentView->Redraw();
2576
2577 return 0;
2578}
2579
2580//==============================================================================
2581//function : VRepaint
2582//purpose :
2583//==============================================================================
2584static int VRepaint (Draw_Interpretor& , Standard_Integer , const char** )
2585{
2586 Handle(V3d_View) V = ViewerTest::CurrentView();
2587 if ( !V.IsNull() ) V->Redraw(); return 0;
2588}
2589
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
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";
2633 di << "filltype can be one of CENTERED, TILED, STRETCH, NONE" << "\n";
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
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 }
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
2693 {
2694 di << "Wrong fill type : " << szType << "\n";
2695 di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2696 return 1;
2697 }
2698 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2699 V3dView->SetBgImageStyle(aFillType, Standard_True);
2700 return 0;
2701}
2702
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
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.;
2730 Quantity_Color aColor1(R1,G1,B1,Quantity_TOC_RGB);
2731
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.;
2735
2736 Quantity_Color aColor2(R2,G2,B2,Quantity_TOC_RGB);
2737 int aType = Draw::Atoi(argv[7]);
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
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 {
2777 int aType = Draw::Atoi(argv[1]);
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
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.;
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
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 }
2844 V3dView->SetAxialScale( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
2845 return 0;
2846}
2847//==============================================================================
2848//function : VTestZBuffTrihedron
2849//purpose : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron
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
2857 V3dView->ZBufferTriedronSetup();
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
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.;
2898 Quantity_Color aColor(R, G, B, Quantity_TOC_RGB);
2899
2900 Standard_Real aScale = Draw::Atof(argv[5]);
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
2933 V3dView->View()->ZFitAll();
2934
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 ) {
2950 V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
2951 return 0;
2952 } else if ( argc == 7 ) {
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]) );
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 ) {
2973 Standard_Real coef = Draw::Atof(argv[1]);
2974 if ( coef <= 0.0 ) {
2975 di << argv[1] << "Invalid value" << "\n";
2976 return 1;
2977 }
2978 V3dView->SetZoom( Draw::Atof(argv[1]) );
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 ) {
2996 V3dView->Pan( Draw::Atoi(argv[1]), Draw::Atoi(argv[2]) );
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
3007//purpose : Export the view to a vector graphic format (PS, EMF, PDF)
3008//==============================================================================
3009
3010static int VExport(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3011{
3012 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3013 if (V3dView.IsNull())
3014 return 1;
3015
3016 if (argc == 1)
3017 {
3018 std::cout << "Usage: " << argv[0] << " Filename [Format]\n";
3019 return 1;
3020 }
3021
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
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)
3082 {
3083 di << "Error: export of image to " << aFormatStr << " failed";
3084 di << " (exception: " << Standard_Failure::Caught()->GetMessageString() << ")";
3085 }
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 ;
3112 Standard_Integer textHeight = 16;
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 {
3120 minRange = Draw::Atof( argv[1] );
3121 maxRange = Draw::Atof( argv[2] );
3122 numIntervals = Draw::Atoi( argv[3] );
3123 }
3124 if ( argc > 4 )
3125 textHeight = Draw::Atoi( argv[4] );
3126 if ( argc > 5 )
3127 position = (Aspect_TypeOfColorScalePosition)Draw::Atoi( argv[5] );
3128 if ( argc > 7 )
3129 {
3130 X = Draw::Atof( argv[6] );
3131 Y = Draw::Atof( argv[7] );
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//==============================================================================
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
3170static int VGraduatedTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3171{
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 }
3179
3180 Handle(V3d_View) aV3dView = ViewerTest::CurrentView();
3181
3182 // Create 3D view if it doesn't exist
3183 if ( aV3dView.IsNull() )
3184 {
3185 ViewerTest::ViewerInit();
3186 aV3dView = ViewerTest::CurrentView();
3187 if( aV3dView.IsNull() )
3188 {
3189 di << "Error: Cannot create a 3D view\n";
3190 return 1; //TCL_ERROR
3191 }
3192 }
3193
3194 // Erase (==0) or display (!=0)
3195 const int display = Draw::Atoi(argv[1]);
3196
3197 if (display)
3198 {
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
3207 const Standard_Boolean isMultibyte = (argc < 7)? Standard_False : (Draw::Atoi(argv[6]) != 0);
3208
3209 // Set axis names
3210 TCollection_ExtendedString xname, yname, zname;
3211 if (argc >= 5)
3212 {
3213 if (isMultibyte)
3214 {
3215 AddMultibyteString(xname, argv[2]);
3216 AddMultibyteString(yname, argv[3]);
3217 AddMultibyteString(zname, argv[4]);
3218 }
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 }
3232
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 }
3247 else
3248 aV3dView->GraduatedTrihedronErase();
3249
3250 ViewerTest::GetAISContext()->UpdateCurrentViewer();
3251 aV3dView->Redraw();
3252
3253 return 0;
3254}
3255
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//==============================================================================
3261static int VPrintView (Draw_Interpretor& di, Standard_Integer argc,
3262 const char** argv)
3263{
3264#ifndef WNT
3265 di << "Printing implemented only for wnt!\n";
3266 return 0;
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];
3289 di << " width height filename [print algo=0] [tile_width tile_height]\n";
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";
3295 di << "using specific tile size if provided\n";
3296 di << "with saving output to an image file\n";
3297 return 1;
3298 }
3299
3300 // get the input params
3301 Standard_Integer aWidth = Draw::Atoi (argv[1]);
3302 Standard_Integer aHeight = Draw::Atoi (argv[2]);
3303 Standard_Integer aMode = 0;
3304 TCollection_AsciiString aFileName = TCollection_AsciiString (argv[3]);
3305 if (argc >= 5)
3306 aMode = Draw::Atoi (argv[4]);
3307
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
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
3327 // define compatible bitmap
3328 HDC anDC = CreateCompatibleDC(0);
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
3344 void* aBitsOut = NULL;
3345 HBITMAP aMemoryBitmap = CreateDIBSection (anDC, &aBitmapData, DIB_RGB_COLORS,
3346 &aBitsOut, NULL, 0);
3347 HGDIOBJ anOldBitmap = SelectObject(anDC, aMemoryBitmap);
3348
3349 Standard_Boolean isSaved = Standard_False, isPrinted = Standard_False;
3350 if (aBitsOut != NULL)
3351 {
3352 if (aMode == 0)
3353 isPrinted = aView->Print(anDC,1,1,0,Aspect_PA_STRETCH);
3354 else
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 }
3373
3374 // succesfully printed into an intermediate buffer
3375 if (isPrinted)
3376 {
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);
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
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 {
3434 di << "Use: vzlayer ";
3435 di << " add/del/get/settings/enable/disable [id]\n";
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";
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";
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
3480 Standard_Integer aDelId = Draw::Atoi (argv[2]);
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 }
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 }
3614 else
3615 {
3616 di << "Invalid operation, please use { add / del / get / settings / enable / disable}\n";
3617 return 1;
3618 }
3619
3620 return 0;
3621}
3622
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;
3651 TCollection_AsciiString myText;
3652 Standard_Real myHeight;
3653 Handle(Visual3d_Layer) myLayer;
3654 Quantity_Color myColor;
3655 Quantity_Color mySubtitleColor;
3656 Aspect_TypeOfDisplayText myType;
3657 TCollection_AsciiString myFontName;
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 ()
3688{
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
3697DEFINE_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
3698
3699// The Visual3d_LayerItem line item for "vlayerline" command
3700// it provides a presentation of line with user-defined
3701// linewidth, linetype and transparency.
3702class V3d_LineItem : public Visual3d_LayerItem
3703{
3704public:
3705 // CASCADE RTTI
3706 DEFINE_STANDARD_RTTI(V3d_LineItem)
3707
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;
3722 V3d_LayerMgrPointer myLayerMgr;
3723 Aspect_TypeOfLine myType;
3724 Standard_Real myWidth;
3725 Standard_Real myTransparency;
3726};
3727
3728IMPLEMENT_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
3729IMPLEMENT_STANDARD_RTTIEXT(V3d_LineItem, Visual3d_LayerItem)
3730
3731// default constructor for line item
3732V3d_LineItem::V3d_LineItem(Standard_Real X1, Standard_Real Y1,
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{
3741 if (myLayerMgr && !myLayerMgr->Overlay().IsNull())
3742 myLayerMgr->Overlay()->AddLayerItem (this);
3743}
3744
3745// render line
3746void V3d_LineItem::RedrawLayerPrs ()
3747{
3748 Handle (Visual3d_Layer) aOverlay;
3749
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
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]);
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)
3807 aWidth = Draw::Atof(argv[5]);
3808
3809 // has type
3810 if (argc > 6)
3811 aType = (Standard_Integer) Draw::Atoi(argv[6]);
3812
3813 // has transparency
3814 if (argc > 7)
3815 {
3816 aTransparency = Draw::Atof(argv[7]);
3817 if (aTransparency < 0 || aTransparency > 1.0)
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
3846 Handle (V3d_LineItem) anItem = new V3d_LineItem(X1, Y1, X2, Y2,
3847 aMgr.operator->(),
3848 aLineType, aWidth,
3849 aTransparency);
3850
3851 // update view
3852 aView->MustBeResized();
3853 aView->Redraw();
3854
3855 return 0;
3856}
3857
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";
3879 di << " display_type = {normal/subtitle/decal/blend/dimension}, (default=normal)\n";
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 }
3884
3885 TCollection_AsciiString aText (argv[1]);
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;
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 {
3901 aColorRed = Draw::Atof (argv[6])/255.;
3902 aColorGreen = Draw::Atof (argv[7])/255.;
3903 aColorBlue = Draw::Atof (argv[8])/255.;
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;
3918 else if (aDispStr.IsEqual ("dimension"))
3919 aTextType = Aspect_TODT_DIMENSION;
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 {
3927 aSubRed = Draw::Atof (argv[10])/255.;
3928 aSubGreen = Draw::Atof (argv[11])/255.;
3929 aSubBlue = Draw::Atof (argv[12])/255.;
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
3941 Quantity_Color aTextColor (aColorRed, aColorGreen,
3942 aColorBlue, Quantity_TOC_RGB);
3943 Quantity_Color aSubtColor (aSubRed, aSubGreen,
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
3957//==============================================================================
3958//function : VGrid
3959//purpose :
3960//==============================================================================
3961
3962static int VGrid (Draw_Interpretor& /*theDI*/,
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
4029 anOriginX = Draw::Atof (theArgVec[anIter++]);
4030 anOriginY = Draw::Atof (theArgVec[anIter++]);
4031 if (aTail == 5)
4032 {
4033 aRStepX = Draw::Atof (theArgVec[anIter++]);
4034 aRStepY = Draw::Atof (theArgVec[anIter++]);
4035 aRotAngle = Draw::Atof (theArgVec[anIter++]);
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
4046 anOriginX = Draw::Atof (theArgVec[anIter++]);
4047 anOriginY = Draw::Atof (theArgVec[anIter++]);
4048 if (aTail == 5)
4049 {
4050 aRadiusStep = Draw::Atof (theArgVec[anIter++]);
4051 aDivisionNumber = Draw::Atoi (theArgVec[anIter++]);
4052 aRotAngle = Draw::Atof (theArgVec[anIter++]);
4053 }
4054
4055 aViewer->SetCircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
4056 aViewer->ActivateGrid (aType, aMode);
4057 }
4058
4059 return 0;
4060}
4061
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
4079 Standard_Integer aFramesNb = (theArgNb > 1) ? Draw::Atoi(theArgVec[1]) : 100;
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
4112//==============================================================================
4113//function : VGlDebug
4114//purpose :
4115//==============================================================================
4116
4117static int VGlDebug (Draw_Interpretor& theDI,
4118 Standard_Integer theArgNb,
4119 const char** theArgVec)
4120{
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 }
4127 if (theArgNb < 2)
4128 {
4129 if (aDriver.IsNull())
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
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;
4151 return 0;
4152}
4153
4154//==============================================================================
4155//function : VVbo
4156//purpose :
4157//==============================================================================
4158
4159static int VVbo (Draw_Interpretor& theDI,
4160 Standard_Integer theArgNb,
4161 const char** theArgVec)
4162{
4163 const Standard_Boolean toSet = (theArgNb > 1);
4164 const Standard_Boolean toUseVbo = toSet ? (Draw::Atoi (theArgVec[1]) == 0) : 1;
4165 if (toSet)
4166 {
4167 ViewerTest_myDefaultCaps.vboDisable = toUseVbo;
4168 }
4169
4170 // get the context
4171 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
4172 if (aContextAIS.IsNull())
4173 {
4174 if (!toSet)
4175 {
4176 std::cerr << "No active view!\n";
4177 }
4178 return 1;
4179 }
4180 Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
4181 if (!aDriver.IsNull())
4182 {
4183 if (!toSet)
4184 {
4185 theDI << (aDriver->Options().vboDisable ? "0" : "1") << "\n";
4186 }
4187 else
4188 {
4189 aDriver->ChangeOptions().vboDisable = toUseVbo;
4190 }
4191 }
4192
4193 return 0;
4194}
4195
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;
4207 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4208 if (!aContext.IsNull())
4209 {
4210 aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContext->CurrentViewer()->Driver());
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";
4218 theDI << "SoftMode:" << (aCaps->contextNoAccel ? "1" : "0") << "\n";
4219 theDI << "FFP: " << (aCaps->ffpEnable ? "1" : "0") << "\n";
4220 return 0;
4221 }
4222
4223 ViewerTest_AutoUpdater anUpdateTool (aContext, ViewerTest::CurrentView());
4224 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
4225 {
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")
4244 {
4245 Standard_Boolean toEnable = Standard_True;
4246 if (++anArgIter < theArgNb
4247 && !parseOnOff (theArgVec[anArgIter], toEnable))
4248 {
4249 --anArgIter;
4250 }
4251 aCaps->vboDisable = !toEnable;
4252 }
4253 else if (anArgCase == "-sprite"
4254 || anArgCase == "-sprites")
4255 {
4256 Standard_Boolean toEnable = Standard_True;
4257 if (++anArgIter < theArgNb
4258 && !parseOnOff (theArgVec[anArgIter], toEnable))
4259 {
4260 --anArgIter;
4261 }
4262 aCaps->pntSpritesDisable = !toEnable;
4263 }
4264 else if (anArgCase == "-softmode")
4265 {
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;
4284 }
4285 else
4286 {
4287 std::cout << "Error: unknown argument '" << anArg << "'\n";
4288 return 1;
4289 }
4290 }
4291 if (aCaps != &ViewerTest_myDefaultCaps)
4292 {
4293 ViewerTest_myDefaultCaps = *aCaps;
4294 }
4295 return 0;
4296}
4297
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
4315 Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
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
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
4363 Image_PixMap::ImgFormat aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA;
4364 Graphic3d_BufferType aBufferType = Graphic3d_BT_RGBA;
4365
4366 Standard_Integer aWidth, aHeight;
4367 aView->Window()->Size (aWidth, aHeight);
4368 const Standard_Integer anX = Draw::Atoi (theArgVec[1]);
4369 const Standard_Integer anY = Draw::Atoi (theArgVec[2]);
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 {
4380 const char* aParam = theArgVec[anIter];
4381 if ( strcasecmp( aParam, "rgb" ) == 0 )
4382 {
4383 aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGB : Image_PixMap::ImgBGR;
4384 aBufferType = Graphic3d_BT_RGB;
4385 }
4386 else if ( strcasecmp( aParam, "hls" ) == 0 )
4387 {
4388 aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGB : Image_PixMap::ImgBGR;
4389 aBufferType = Graphic3d_BT_RGB;
4390 toShowHls = Standard_True;
4391 }
4392 else if ( strcasecmp( aParam, "rgbf" ) == 0 )
4393 {
4394 aFormat = Image_PixMap::ImgRGBF;
4395 aBufferType = Graphic3d_BT_RGB;
4396 }
4397 else if ( strcasecmp( aParam, "rgba" ) == 0 )
4398 {
4399 aFormat = Image_PixMap::IsBigEndianHost() ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA;
4400 aBufferType = Graphic3d_BT_RGBA;
4401 }
4402 else if ( strcasecmp( aParam, "rgbaf" ) == 0 )
4403 {
4404 aFormat = Image_PixMap::ImgRGBAF;
4405 aBufferType = Graphic3d_BT_RGBA;
4406 }
4407 else if ( strcasecmp( aParam, "depth" ) == 0 )
4408 {
4409 aFormat = Image_PixMap::ImgGrayF;
4410 aBufferType = Graphic3d_BT_Depth;
4411 }
4412 else if ( strcasecmp( aParam, "name" ) == 0 )
4413 {
4414 toShowName = Standard_True;
4415 }
4416 }
4417
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))
4425 {
4426 std::cerr << "Image dump failed\n";
4427 return 1;
4428 }
4429
4430 Quantity_Parameter anAlpha;
4431 Quantity_Color aColor = anImage.PixelColor (anX, anY, anAlpha);
4432 if (toShowName)
4433 {
4434 if (aBufferType == Graphic3d_BT_RGBA)
4435 {
4436 theDI << Quantity_Color::StringName (aColor.Name()) << " " << anAlpha;
4437 }
4438 else
4439 {
4440 theDI << Quantity_Color::StringName (aColor.Name());
4441 }
4442 }
4443 else
4444 {
4445 switch (aBufferType)
4446 {
4447 default:
4448 case Graphic3d_BT_RGB:
4449 {
4450 if (toShowHls)
4451 {
4452 theDI << aColor.Hue() << " " << aColor.Light() << " " << aColor.Saturation();
4453 }
4454 else
4455 {
4456 theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue();
4457 }
4458 break;
4459 }
4460 case Graphic3d_BT_RGBA:
4461 {
4462 theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue() << " " << anAlpha;
4463 break;
4464 }
4465 case Graphic3d_BT_Depth:
4466 {
4467 theDI << aColor.Red();
4468 break;
4469 }
4470 }
4471 }
4472
4473 return 0;
4474}
4475
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
4494 Standard_Real aTolColor = Draw::Atof (theArgVec[3]);
4495 if (aTolColor < 0.0)
4496 aTolColor = 0.0;
4497 if (aTolColor > 1.0)
4498 aTolColor = 1.0;
4499
4500 Standard_Boolean toBlackWhite = (Draw::Atoi (theArgVec[4]) == 1);
4501 Standard_Boolean isBorderFilterOn = (Draw::Atoi (theArgVec[5]) == 1);
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
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
4533// pixel positions (x1,y1),...,(xn,yn)
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{
4540 if(argc < 3)
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();
4547 if(myAIScontext.IsNull())
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
4592//purpose : Emulates cursor movement to defined pixel position
4593//=======================================================================
4594static Standard_Integer VMoveTo (Draw_Interpretor& di,
4595 Standard_Integer argc,
4596 const char ** argv)
4597{
4598 if(argc != 3)
4599 {
4600 di << "Usage : " << argv[0] << " x y" << "\n";
4601 return 1;
4602 }
4603
4604 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4605 if(aContext.IsNull())
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
4614//=================================================================================================
4615//function : VViewParams
4616//purpose : Gets or sets AIS View characteristics
4617//=================================================================================================
4618static int VViewParams (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
4619{
4620 Handle(V3d_View) anAISView = ViewerTest::CurrentView();
4621 if (anAISView.IsNull())
4622 {
4623 std::cout << theArgVec[0] << ": please initialize or activate view.\n";
4624 return 1;
4625 }
4626
4627 if (theArgsNb == 1)
4628 {
4629 // print all of the available view parameters
4630 Quantity_Factor anAISViewScale = anAISView->Scale();
4631
4632 Standard_Real anAISViewProjX = 0.0;
4633 Standard_Real anAISViewProjY = 0.0;
4634 Standard_Real anAISViewProjZ = 0.0;
4635 anAISView->Proj (anAISViewProjX, anAISViewProjY, anAISViewProjZ);
4636
4637 Standard_Real anAISViewUpX = 0.0;
4638 Standard_Real anAISViewUpY = 0.0;
4639 Standard_Real anAISViewUpZ = 0.0;
4640 anAISView->Up (anAISViewUpX, anAISViewUpY, anAISViewUpZ);
4641
4642 Standard_Real anAISViewAtX = 0.0;
4643 Standard_Real anAISViewAtY = 0.0;
4644 Standard_Real anAISViewAtZ = 0.0;
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;
4658 }
4659
4660 // -------------------------
4661 // Parse options and values
4662 // -------------------------
4663
4664 NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfKeysByValues;
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();
4675 aMapOfKeysByValues.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
4676 continue;
4677 }
4678
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
4686 aMapOfKeysByValues(aParseKey)->Append (anArg);
4687 }
4688
4689 // ---------------------------------------------
4690 // Change or print parameters, order plays role
4691 // ---------------------------------------------
4692
4693 // Check arguments for validity
4694 NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfKeysByValues);
4695 for (; aMapIt.More(); aMapIt.Next())
4696 {
4697 const TCollection_AsciiString& aKey = aMapIt.Key();
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))
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 }
4716 }
4717
4718 Handle(TColStd_HSequenceOfAsciiString) aValues;
4719
4720 // Change view parameters in proper order
4721 if (aMapOfKeysByValues.Find ("SCALE", aValues))
4722 {
4723 if (aValues->IsEmpty())
4724 {
4725 theDi << "Scale: " << anAISView->Scale() << "\n";
4726 }
4727 else
4728 {
4729 anAISView->SetScale (aValues->Value(1).RealValue());
4730 }
4731 }
4732 if (aMapOfKeysByValues.Find ("SIZE", aValues))
4733 {
4734 if (aValues->IsEmpty())
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 {
4743 anAISView->SetSize (aValues->Value(1).RealValue());
4744 }
4745 }
4746 if (aMapOfKeysByValues.Find ("EYE", aValues))
4747 {
4748 if (aValues->IsEmpty())
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 {
4758 anAISView->SetEye (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
4759 }
4760 }
4761 if (aMapOfKeysByValues.Find ("AT", aValues))
4762 {
4763 if (aValues->IsEmpty())
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 {
4773 anAISView->SetAt (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
4774 }
4775 }
4776 if (aMapOfKeysByValues.Find ("PROJ", aValues))
4777 {
4778 if (aValues->IsEmpty())
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 {
4788 anAISView->SetProj (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
4789 }
4790 }
4791 if (aMapOfKeysByValues.Find ("UP", aValues))
4792 {
4793 if (aValues->IsEmpty())
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 {
4803 anAISView->SetUp (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
4804 }
4805 }
4806 if (aMapOfKeysByValues.Find ("CENTER", aValues))
4807 {
4808 anAISView->SetCenter (aValues->Value(1).IntegerValue(), aValues->Value(2).IntegerValue());
4809 }
4810
4811 return 0;
4812}
4813
4814//=======================================================================
4815//function : VChangeSelected
4816//purpose : Adds the shape to selection or remove one from it
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 }
4850 else
4851 {
4852 aContext->AddOrRemoveCurrentObject(anAISObject);
4853 }
4854 }
4855 return 0;
4856}
4857
4858//=======================================================================
4859//function : VZClipping
4860//purpose : Gets or sets ZClipping mode, width and depth
4861//=======================================================================
4862static Standard_Integer VZClipping (Draw_Interpretor& di,
4863 Standard_Integer argc,
4864 const char ** argv)
4865{
4866 if(argc>4)
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();
4873 if(aContext.IsNull())
4874 {
4875 di << "use 'vinit' command before " << argv[0] << "\n";
4876 return 1;
4877 }
4878 Handle(V3d_View) aView = ViewerTest::CurrentView();
4879 V3d_TypeOfZclipping aZClippingMode = V3d_OFF;
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;
4933 }
4934 aView->SetZClippingType(aZClippingMode);
4935 }
4936 if(argc >2)
4937 {
4938 Quantity_Length aDepth = 0., aWidth = 1.;
4939 if(argc == 3)
4940 {
4941 aDepth = Draw::Atof (argv[1]);
4942 aWidth = Draw::Atof (argv[2]);
4943 }
4944 else if(argc == 4)
4945 {
4946 aDepth = Draw::Atof (argv[2]);
4947 aWidth = Draw::Atof (argv[3]);
4948 }
4949
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
4973//purpose : Returns number of selected objects
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
4996//purpose : Switches altialiasing on or off
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
5027//purpose : Switches altialiasing on or off
5028//=======================================================================
5029static Standard_Integer VPurgeDisplay (Draw_Interpretor& di,
5030 Standard_Integer argc,
5031 const char ** argv)
5032{
5033 if (argc > 1)
5034 {
5035 di << "Usage : " << argv[0] << "\n";
5036 return 1;
5037 }
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);
5045 di << aContext->PurgeDisplay() << "\n";
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 }
5068 Standard_Real aSize = Draw::Atof (argv[1]);
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 }
5099 Standard_Real Dx = Draw::Atof (argv[1]);
5100 Standard_Real Dy = Draw::Atof (argv[2]);
5101 Standard_Real Dz = Draw::Atof (argv[3]);
5102 Standard_Boolean aStart = Standard_True;
5103 if (argc == 5)
5104 {
5105 aStart = (Draw::Atoi (argv[4]) > 0);
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 }
5132 Standard_Real Dx = Draw::Atof (argv[1]);
5133 Standard_Real Dy = Draw::Atof (argv[2]);
5134 Standard_Real Dz = Draw::Atof (argv[3]);
5135 Standard_Boolean aStart = Standard_True;
5136 if (argc == 5)
5137 {
5138 aStart = (Draw::Atoi (argv[4]) > 0);
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 }
5163 Standard_Real Ax = Draw::Atof (argv[1]);
5164 Standard_Real Ay = Draw::Atof (argv[2]);
5165 Standard_Real Az = Draw::Atof (argv[3]);
5166 Standard_Boolean aStart = Standard_True;
5167 if (argc == 5)
5168 {
5169 aStart = (Draw::Atoi (argv[4]) > 0);
5170 }
5171
5172 Handle(V3d_View) aView = ViewerTest::CurrentView();
5173 aView->Turn(Ax,Ay,Az,aStart);
5174 return 0;
5175}
5176
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
5227static int VTextureEnv (Draw_Interpretor& /*theDI*/, Standard_Integer theArgNb, const char** theArgVec)
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
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
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]);
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
5594 Standard_Real aRed = Draw::Atof (theArgVec [5]);
5595 Standard_Real aGrn = Draw::Atof (theArgVec [6]);
5596 Standard_Real aBlu = Draw::Atof (theArgVec [7]);
5597
5598 Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
5599 Quantity_Color aColor (aRed, aGrn, aBlu, Quantity_TOC_RGB);
5600 aMat.SetAmbientColor (aColor);
5601 aMat.SetDiffuseColor (aColor);
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
5749//===============================================================================================
5750//function : VZRange
5751//purpose :
5752//===============================================================================================
5753static int VZRange (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
5754{
5755 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
5756
5757 if (aCurrentView.IsNull())
5758 {
5759 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
5760 return 1;
5761 }
5762
5763 Handle(Graphic3d_Camera) aCamera = aCurrentView->Camera();
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 {
5774 Standard_Real aNewZNear = Draw::Atof (theArgVec[1]);
5775 Standard_Real aNewZFar = Draw::Atof (theArgVec[2]);
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);
5791 }
5792 else
5793 {
5794 std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
5795 return 1;
5796 }
5797
5798 aCurrentView->Redraw();
5799
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{
5809 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
5810
5811 if (aCurrentView.IsNull())
5812 {
5813 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
5814 return 1;
5815 }
5816
5817 Standard_Real aScale = aCurrentView->View()->AutoZFitScaleFactor();
5818
5819 if (theArgsNb > 3)
5820 {
5821 std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
5822 return 1;
5823 }
5824
5825 if (theArgsNb < 2)
5826 {
5827 theDi << "Auto z-fit mode: " << "\n"
5828 << "On: " << (aCurrentView->View()->AutoZFitMode() ? "enabled" : "disabled") << "\n"
5829 << "Scale: " << aScale << "\n";
5830 return 0;
5831 }
5832
5833 Standard_Boolean isOn = Draw::Atoi (theArgVec[1]) == 1;
5834
5835 if (theArgsNb >= 3)
5836 {
5837 aScale = Draw::Atoi (theArgVec[2]);
5838 }
5839
5840 aCurrentView->View()->SetAutoZFitMode (isOn, aScale);
5841 aCurrentView->View()->AutoZFit();
5842 aCurrentView->Redraw();
5843
5844 return 0;
5845}
5846
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
5861//===============================================================================================
5862//function : VCamera
5863//purpose :
5864//===============================================================================================
5865static int VCamera (Draw_Interpretor& theDI,
5866 Standard_Integer theArgsNb,
5867 const char** theArgVec)
5868{
5869 Handle(V3d_View) aView = ViewerTest::CurrentView();
5870 if (aView.IsNull())
5871 {
5872 std::cout << "Error: no active view.\n";
5873 return 1;
5874 }
5875
5876 Handle(Graphic3d_Camera) aCamera = aView->Camera();
5877 if (theArgsNb < 2)
5878 {
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;
5887 }
5888
5889 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
5890 {
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")
5903 {
5904 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
5905 }
5906 else if (anArgCase == "-persp"
5907 || anArgCase == "-perspective"
5908 || anArgCase == "-perspmono"
5909 || anArgCase == "-perspectivemono"
5910 || anArgCase == "-mono")
5911 {
5912 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
5913 }
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")
5927 {
5928 aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
5929 }
5930 else if (anArgCase == "-right"
5931 || anArgCase == "-righteye"
5932 || anArgCase == "-monoright"
5933 || anArgCase == "-monorighteye"
5934 || anArgCase == "-perpsright")
5935 {
5936 aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
5937 }
5938 else if (anArgCase == "-dist"
5939 || anArgCase == "-distance")
5940 {
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() << " ";
5950 }
5951 else if (anArgCase == "-iod")
5952 {
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() << " ";
5962 }
5963 else if (anArgCase == "-iodtype")
5964 {
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 }
5992 }
5993 else if (anArgCase == "-zfocus")
5994 {
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() << " ";
6004 }
6005 else if (anArgCase == "-zfocustype")
6006 {
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")
6037 {
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() << " ";
6047 }
6048 else
6049 {
6050 std::cout << "Error: unknown argument '" << anArg << "'\n";
6051 return 1;
6052 }
6053 }
6054
6055 aView->View()->AutoZFit();
6056 aView->Redraw();
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
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;
6124 if (!ViewerTest::SplitParameter (anArg, aKey, aValue)
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
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 }
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 }
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 }
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 }
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
6639//=======================================================================
6640//function : VRenderParams
6641//purpose : Enables/disables rendering features
6642//=======================================================================
6643
6644static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
6645 Standard_Integer theArgNb,
6646 const char** theArgVec)
6647{
6648 Handle(V3d_View) aView = ViewerTest::CurrentView();
6649 if (aView.IsNull())
6650 {
6651 std::cerr << "Error: no active viewer!\n";
6652 return 1;
6653 }
6654
6655 Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
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 }
6695
6696 if (theArgNb < 2)
6697 {
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";
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";
6719 return 0;
6720 }
6721
6722 Standard_Boolean toPrint = Standard_False;
6723 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
6724 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
6725 {
6726 Standard_CString anArg (theArgVec[anArgIter]);
6727 TCollection_AsciiString aFlag (anArg);
6728 aFlag.LowerCase();
6729 if (anUpdateTool.parseRedrawMode (aFlag))
6730 {
6731 continue;
6732 }
6733 else if (aFlag == "-echo"
6734 || aFlag == "-print")
6735 {
6736 toPrint = Standard_True;
6737 anUpdateTool.Invalidate();
6738 }
6739 else if (aFlag == "-mode"
6740 || aFlag == "-rendermode"
6741 || aFlag == "-render_mode")
6742 {
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 }
6752 else
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;
6768 }
6769 else if (aFlag == "-rast"
6770 || aFlag == "-raster"
6771 || aFlag == "-rasterization")
6772 {
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 }
6801 else
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;
6871 }
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 }
6924 else
6925 {
6926 std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
6927 return 1;
6928 }
6929 }
6930 return 0;
6931}
6932
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
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
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
7091//=======================================================================
7092//function : ViewerCommands
7093//purpose :
7094//=======================================================================
7095
7096void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
7097{
7098
7099 const char *group = "ZeViewer";
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",
7119 __FILE__,VInit,group);
7120 theCommands.Add("vclose" ,
7121 "[view_id [keep_context=0|1]]\n"
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);
7137 theCommands.Add("vhelp" ,
7138 "vhelp : display help on the viewer commands",
7139 __FILE__,VHelp,group);
7140 theCommands.Add("vtop" ,
7141 "vtop or <T> : Top view" ,
7142 __FILE__,VTop,group);
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);
7152 theCommands.Add("vaxo" ,
7153 " vaxo or <A> : Axonometric view ",
7154 __FILE__,VAxo,group);
7155 theCommands.Add("vfront" ,
7156 "vfront : Front view" ,
7157 __FILE__,VFront,group);
7158 theCommands.Add("vback" ,
7159 "vback : Back view" ,
7160 __FILE__,VBack,group);
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);
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);
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);
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);
7186 theCommands.Add("vsetbgmode",
7187 "vsetbgmode : vsetbgmode filltype : Change background image fill type",
7188 __FILE__,VSetBgMode,group);
7189 theCommands.Add("vsetgradientbg",
7190 "vsetgradientbg : vsetgradientbg r1 g1 b1 r2 g2 b2 filltype : Mount gradient background",
7191 __FILE__,VSetGradientBg,group);
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);
7198 theCommands.Add("vscale",
7199 "vscale : vscale X Y Z",
7200 __FILE__,VScale,group);
7201 theCommands.Add("vzbufftrihedron",
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",
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",
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",
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",
7224 "vgraduatedtrihedron : 1/0 (display/erase) [Xname Yname Zname [Font [isMultibyte]]]",
7225 __FILE__,VGraduatedTrihedron,group);
7226 theCommands.Add("vprintview" ,
7227 "vprintview : width height filename [algo=0] [tile_width tile_height] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
7228 __FILE__,VPrintView,group);
7229 theCommands.Add("vzlayer",
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",
7244 __FILE__,VZLayer,group);
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);
7253 theCommands.Add("vlayerline",
7254 "vlayerline : vlayerline x1 y1 x2 y2 [linewidth=0.5] [linetype=0] [transparency=1.0]",
7255 __FILE__,VLayerLine,group);
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);
7261 theCommands.Add ("vfps",
7262 "vfps [framesNb=100] : estimate average frame rate for active view",
7263 __FILE__, VFps, group);
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);
7269 theCommands.Add ("vvbo",
7270 "vvbo [{0|1}] : turn VBO usage On/Off; affects only newly displayed objects",
7271 __FILE__, VVbo, group);
7272 theCommands.Add ("vstereo",
7273 "\nvstereo [{0|1}] : turn stereo usage On/Off; affects only newly displayed objects",
7274 __FILE__, VStereo, group);
7275 theCommands.Add ("vcaps",
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.",
7290 __FILE__, VCaps, group);
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);
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);
7299 theCommands.Add("diffimage",
7300 "diffimage : diffimage imageFile1 imageFile2 toleranceOfColor(0..1) blackWhite(1|0) borderFilter(1|0) [diffImageFile]",
7301 __FILE__, VDiffImage, group);
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);
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"
7317 " [-proj [x y z]] [-center x y] [-size sx]\n"
7318 "- Gets or sets current view parameters.\n"
7319 "- If called without arguments, all view parameters are printed.\n"
7320 "- The options are:\n"
7321 " -scale [s] : prints or sets viewport relative scale.\n"
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"
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",
7329 __FILE__, VViewParams, group);
7330 theCommands.Add("vchangeselected",
7331 "vchangeselected shape"
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);
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);
7365 theCommands.Add ("vautozfit", "command to enable or disable automatic z-range adjusting\n"
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);
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);
7375 theCommands.Add("vantialiasing",
7376 "vantialiasing 1|0",
7377 __FILE__,VAntialiasing,group);
7378 theCommands.Add ("vpurgedisplay",
7379 "vpurgedisplay"
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);
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);
7408 theCommands.Add("vhlr" ,
7409 "is_enabled={on|off} [show_hidden={1|0}]"
7410 " - Hidden line removal algorithm:"
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",
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);
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);
7447 theCommands.Add("vdefaults",
7448 "vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]",
7449 __FILE__, VDefaults, group);
7450 theCommands.Add("vlight",
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",
7470 __FILE__, VLight, group);
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);
7477 theCommands.Add("vrenderparams",
7478 "\n Manages rendering parameters: "
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.",
7491 __FILE__, VRenderParams, group);
7492 theCommands.Add("vfrustumculling",
7493 "vfrustumculling [toEnable]: enables/disables objects clipping",
7494 __FILE__,VFrustumCulling,group);
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
7500
7501 theCommands.Add("vxrotate",
7502 "vxrotate",
7503 __FILE__,VXRotate,group);
7504
7505}
Open CASCADE Technology repository