Sample Name | Availability |
---|---|
3D Part Viewer | Windows |
C# Simple | Windows |
Cocoa Simple | MacOS |
Holographic Remoting Simple | Windows with HoloLens |
Hololens Simple | Windows with HoloLens |
Java Simple | Windows, Linux |
Java Simple SWT | Windows |
MFC Simple | Windows |
MFC Simple - 3DGS Only | Windows |
Out-of-Core Pre-Processor | Windows |
OpenVR Simple | Windows with OpenVR headset |
Parasolid Part Viewer | Windows |
Qt Simple | Windows, Linux & MacOS |
Win32 Simple | Windows |
WPF Image | Windows |
WPF Simple | Windows |
Below are instructions for using the sandboxes available in Visualize downloadable packages. Each section includes a general description along with instructions for building and running the sandbox application.
The table on the right includes a full list of the available sandboxes, along with the supported OS for each sandbox.
Note: Throughout this document hoops_dir refers to the directory where the HOOPS 3DF package is located on your system.
Description: The Part Viewer is an example of a fully featured application which showcases many of the features available in HOOPS. For a full description of the functionality available in this application, please visit: Reference Applications section.
Availability: Windows only
How to Run:
Launch hoops3dpartviewer.exe
from hoops_dir/bin/<platform>
How to Build:
hoopspartviewer
project and choose 'Build'Command Line Arguments:
The 3D Part Viewer supports limited command line arguments to make it faster to load and export files. They follow this pattern:
hoops3dpartviewer.exe [input_file] [options]
Valid values for options are:
Command Line Argument | Description |
---|---|
–help, -h | Shows usage message |
–output, -o <output_file_name> | Name of file to export |
When an input file is specified, it is loaded at startup. If an input file is specified, an output file can optionally be passed as well. This will cause the application to export the file as soon as it is loaded. The export format will be implied based on the extension of the output file name.
Description: Simple sandbox application built with the intent to show how to use the C# 3DF API together with Windows Forms GUI toolkit. It allows users to load HSF and HMF files, create spheres, cones, cylinders and annotations. When the orbit operator is active, the camera can be orbited using the left mouse button, panned using the right mouse button, and zoomed using the mouse wheel. The scene can be sent to a printer, and the code shows how hardcopy support can be added to a C# application. It is meant as a starting point for customers to prototype their applications. It uses the DirectX 11 driver by default.
Availability: Windows only
How to Run: Launch csharp_simple.exe
from hoops_dir/bin/<platform>
How to Build:
csharp_simple_cs
project and choose 'Build'
Description: Cocoa Simple
shows customers how to add HOOPS Visualize to a MacOS application built using the Cocoa GUI toolkit. It allows users to load HSF and HMF files, manipulate the camera and add annotations to the scene.
Availability: MacOS
How to Run: Launch cocoa_simple.app
from hoops_dir/bin/<platform>
How to Build:
cocoa_simple
scheme and choose BuildDescription: The Holographic Remoting Simple sample shows how to create an AR application which renders its content locally on a machine but is displayed remotely on the HoloLens.
It is meant as a starting point for customers to prototype their applications.
Availability: Windows only
How to Run:
holographic_remoting_simple_v<version>.exe
passing to it the appropriate command line argumentsCommand Line Argument | Description |
---|---|
-ip <ip_address> | IP address of the HoloLens, acquired in step 3. This argument is required. |
-filename <file_to_load> | Path to the file to load in the sandbox. Only HSF, HMF, STL and OBJ files are supported by this sample. |
-scale <model_scale> | Amount by which to scale the model. Defaults to 1 |
-offset <offset_x,offset_y,offset_z> | Three comma-separated numbers which indicate the amount by which to translate the model along the X-, Y- and Z-axes respectively. Example: -offset 1,0,0 Defaults to no offsets |
How to Build:
holographic_remoting_simple
project and choose 'Build'Important: The Hololens Simple project is only available in 32-bit packages of Visualize – please be sure to download the 32-bit package to access this sample.
Description: This sample project is named hololens_simple, which is located in demo/uwp and can be accessed via the samples_arvr_v141 solution in the root folder of the Visualize package. In contrast to the HoloLens remoting sample, this sandbox creates an application to be deployed directly onto the HoloLens hardware.
Native HoloLens applications are compatible with the DX11 graphics driver only. Also, it requires the HOOPS UWP libraries, and the ability to build UWP apps (Visual Studio should prompt you to install the requirements if they aren't already present).
For compatibility with the 32-bit HoloLens hardware, the sample is configured to generate 32-bit binaries.
How to Build:
hololens_simple_v1xx
project and choose 'Build'In order to add native HoloLens support to your application, the following items are required:
Here are the basic steps for setting up your application:
Set Up PC and HoloLens
You must enable Developer mode on both the PC and HoloLens, and pair the devices, to allow deployment from Visual Studio on the PC to the HoloLens device. For details, see Microsoft's documentation here: https://docs.microsoft.com/en-us/windows/mixed-reality/using-visual-studio
How to Run:
hololens_simple
project, right-click Content
and select Add->Existing Item
Properties
, go to the General
section, in the Content
field change the value to Yes
. filename
variable in hololens_simpleMain.cpp
to the name of your HSF file. Description: Simple sandbox application built with the intent to show how to use the Java 3DF API with the Java AWT GUI toolkit. This sandbox provides basic functionalities, like loading files, manipulating the camera, creating simple geometries and selecting parts in the scene. It is meant as a starting point for customers to prototype their applications. It uses the OpenGL driver by default.
Availability: Available on Windows, Linux and MacOS
How to Run:
Java
is somewhere in your path. To verify that this is the case try executing the 'java -version'
command from the terminal and verify that the version of Java
you have installed is returned to you as a stringexport LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
java_simple
using the following command How to Build:
There are a few important notes about building java_simple
, which apply to all the platforms:
java_simple
in debug mode, it should target the release version of 3DF libraries.java_simple.java
, found in hoops_dir/demo/java/java_simple and add your HOOPS license in the constructor of the JSimpleApplication
classjava_simple
in 32-bit mode on a 64-bit system using a 64-bit JDK installation is not allowed.METHOD 1: Using Visual Studio in Release Mode
java_simple_v<version>.vcxproj
project, found at hoops_dir/demo/java/java_simple to the samples solutionJDK_INSTALL_DIR
which points to the directory containing the Java Development Kit.java_simple
project and choose 'Build' Once the project is built using Visual Studio, it can be launched using the command line instruction detailed in the How to Run section.METHOD 2: Using Visual Studio in Debug Mode
java_simple_v<version>.vcxproj
project, found at hoops_dir/demo/java/java_simple to the samples solutionJDK_INSTALL_DIR
which points to the directory containing the Java Development Kit.java_simple
project and choose Properties java_simple
project and choose 'Build' Once the project is built using Visual Studio, it can be launched using the command line instruction detailed in the How to Run section.
METHOD 3: Using Eclipse
java_simple.java
, found in hoops_dir/demo/java/java_simple to the directory created in the previous stepjava_simple.java
file should now be visible within the Package Explorer pane.java_simple
from the dialog which pops up.java_simple
can be run directly from it, rather than using the command line./usr/lib/jvm
And create a symlink to the directory where your Java JDK is located as follows:It is important that the name of the symlink be exactly java-6-sun
java_simple
: Linux packages of HOOPS Visualize 3DF do not ship with debug libraries, but our makefiles are nevertheless setup to try to link against the debug version of our libraries when building a project in debug mode. Because of this, our makefiles need to be modified before building the Java Simple
sample in debug mode.
./javac
can be called from any directory. Navigate to the following directory /usr/lib/jvm, and create a symlink to the directory where your Java JDK is located as follows:
It is important that the name of the symlink be exactly java-6-sun
Navigate to hoops_dir/demo/java and open the java.mk file with a text editor and perform the following edits:
a. Comment out the project dependencies as follows
Since we want to link against the release version of the HOOPS libraries, which are distributed with the package, there is no need to rebuild them.
b. Comment out the make commands for directories other than java_simple
as done above, by prepending '#' to the line containing those instructions
c. Change this line:
cd ./demo/java/java_simple && BIN_PATH=../../../
to this:
cd ./demo/java/java_simple && BIN_PATH=../../../bin/linux_x86_64
Navigate to the main hoops directory, and use the following command to compile java_simple
:
make java_simple CONFIG=debug
The resulting debug application will be created in the release bin directory (i.e., hoops_dir/bin/linux_x86_64)
Description: Simple sandbox application built with the intent to show how to use the Java 3DF API with the Java SWT GUI toolkit. This sandbox provides basic functionalities, like loading files, manipulating the camera, creating simple geometries and selecting parts in the scene. It is meant as a starting point for customers to prototype their applications. It uses the OpenGL driver by default.
Availability: Windows only
How to Run:
How to Build: There are a few important notes about building java_simple
, which apply to all the platforms:
java_simple_swt
in debug mode, it should target the release version of 3DF libraries.java_simple_swt.java
, found in hoops_dir/demo/java/java_simple_swt and add your HOOPS license in the constructor of the SWTApplication
classjava_simple_swt
in 32-bit mode on a 64-bit system using a 64-bit JDK installation is not allowed.METHOD 1: Using Visual Studio in Release Mode
java_simple_swt_v<version>.vcxproj
project, found at hoops_dir/demo/java/java_simple_swt to the samples solutionJDK_INSTALL_DIR
which points to the directory containing the Java Development Kit.java_simple_swt
project and choose 'Build' Once the project is built using Visual Studio, it can be launched using the command line instruction detailed in the How to Run section.METHOD 2: Using Visual Studio in Debug Mode
java_simple_swt_v<version>.vcxproj
project, found at hoops_dir/demo/java/java_simple to the samples solutionJDK_INSTALL_DIR
which points to the directory containing the Java Development Kit.java_simple_swt
project and choose 'Build'. The resulting debug application will be created in the release bin directory. Once the project is built using Visual Studio, it can be launched using the command line instruction detailed in the How to Run section.METHOD 3: Using Eclipse
java_simple_swt.java
, found in hoops_dir/demo/java/java_simple_swt to the directory created in the previous stepjava_simple_swt.java
file should now be visible within the Package Explorer pane.java_simple_swt
from the dialog which pops up.java_simple_swt
can be run directly from it, rather than using the command line.Description: Simple sandbox application built with the intent to show how to create an MFC application using the MVO API. Users can load HSF and HMF files.
Interaction with the scene consists of standard camera manipulation (pan, zoom, orbit, zooming to extents and zooming to a particular area), as well as the ability to create cylinders, cones, spheres.
Users can also select and highlight geometry using the Select by Window operator.
Three different render modes are exposed through the View menu (Gouraud, Hidden Line and Wireframe).
Finally, the scene can be copied to the system clipboard or sent to a printer.
An extra, unused button is added at the end of the toolbar so that customers can quickly add and try some code in the sandbox. It is meant as a starting point for customers to prototype their applications.
Availability: Windows only
How to Run: Launch mfc_simple.exe
from hoops_dir/bin/<platform>
How to Build:
mfc_simple
project and choose 'Build'Description: MFC Simple – 3DGS Only is a stripped-down version of the MFC Simple application. It only links against the main HOOPS Visualize library, showing customers how to write an MFC application when they do not wish to use the MVO component of Visualize.
This sample is relevant for customers who wish to handle input from the user from an MFC application, but without using MVO. It supports loading HMF files, changing render modes and orbiting the camera.
Availability: Windows
How to Run:
MFC Simple – 3DGS Only
needs to be built before it can be run. Please see the next section for instructions on how to build it.
Once it is built, it can be run as follows:
Launch simple.exe
from hoops_dir/bin/<platform>
How to Build:
simple_v<version>
project and choose 'Build'Description: The Out of Core Pre-Processor is used to turn ASCII point cloud files into a specially processed HSF file with the .ooc extension. Pre-processing a large point cloud is the first step towards visualizing very large point clouds with 3DF. A full description of the OOC functionality can be found in the OOC Technical Overview.
Availability: Windows only
How to Run:
Launch ooc.exe
from hoops_dir/bin/<platform>, providing appropriate command line arguments. ooc.exe
can be launched with the –help command line to see a description of all the available options.
How to Build: ooc.exe
cannot be built by the user.
Description: OpenVR Simple shows how to create a simple VR viewing application. The user can use this sandbox to see how to use the VR API, how to collect data from VR controllers and how to create VR operators to interact with the scene. If two controllers are connected, the user will be able to move, rotate and scale the model, and to highlight parts of it. It is meant as a starting point for customers to prototype their applications.
Availability: Windows only
How to Run: Launch openvr_simple_<version>.exe
from hoops_dir/bin/<platform>, providing appropriate command line arguments.
There are two command line options which can be passed to openvr_simple
:
Command Line Argument | Description |
---|---|
-filename <file_to_load> | The file to load in VR |
-driver <driver_name> | The driver to use. Valid options are dx11 and opengl2. Defaults to dx11. |
A VR headset that supports OpenVR needs to be connected before launching OpenVR Simple.
How to Build:
Description: The Parasolid Part Viewer is an example of a fully featured application which showcases how developers can use Parasolid together with HOOPS. For a full description of the functionality available in this application, please visit the Reference Applications section.
Availability: Windows only
How to Run: Launch parasolidpartviewer.exe from hoops_dir/bin/<platform>
How to Build: Prerequisites:
PARASOLID_INSTALL_DIR
environment variable should contain all the different versions of Parasolid you are interested in for a release. For example, if you are using Parasolid 30, and are interested in building 64-bit applications for Visual Studio 2017, you should place the appropriate Parasolid version in PARASOLID_INSTALL_DIR/base64_vc14.These are the different directories that our Parasolid projects will look for, based on which compiler you are using:
Building in Release mode
parasolidpartviewer_v<version>.vcxproj
project, found at hoops_dir/demo/mfc/parasolidpartviewer to the samples solutionparasolidpartviewer_v<version>
project and choose 'Build'Building in Debug mode
The Parasolid Part Viewer cannot be currently built in Debug mode from our packages.
Command Line Arguments: The Parasolid Part Viewer supports limited command line arguments to make it faster to load and export files. They follow this pattern:
Valid values for options are:
Command Line Argument | Description |
---|---|
--help, -h | Shows usage message |
--output, -o <output_file_name> | Name of file to export |
When an input file is specified, it is loaded at startup. If an input file is specified, an output file can optionally be passed as well. This will cause the application to export the file as soon as it is loaded. The export format will be implied based on the extension of the output file name.
Description: The Qt Simple
sandbox shows how to create a platform independent GUI application which uses the HOOPS API together with Qt. This sandbox provides basic functionalities, like loading files, manipulating the camera, and creating simple geometries. It is meant as a starting point for customers to prototype their applications.
Availability: Available on Windows, Linux and MacOS
How to Run:
Before attempting to run Qt Simple make sure that Qt is installed on your machine, and that it is somewhere in your PATH.
qt_simple.exe
from hoops_dir/bin/<platform> QSimple
from hoops_dir/bin/<platform> QSimple
needs to be built before it can be launched. Please follow the instruction in the MacOS section of 'How to Build' to learn how to build this sample.How to Build:
Windows:
Linux:
Building in Release mode
Make QSimple CONFIG=release
Building in Debug mode Linux packages of HOOPS Visualize 3DF do not ship with debug libraries, but our makefiles are nevertheless setup to try to link against debug version of our libraries when building a project in debug mode. Because of this, our makefiles need to be modified before building the Qt Simple sample in debug mode.
To this:
The resulting debug application will be created in the release bin directory (i.e. hoops_dir/bin/linux_x86_64)
MacOS:
QSimple.xcodeproj
XCode project found in hoops_dir/demo/qt/qt_simple.XCode / Preferences / Locations / Custom Paths
. You can find which version of Qt is supported by which version of HOOPS from the Release Notes.QSimple
project from XCodeDescription: Win32 Simple
is a sandbox demonstrating how customers can get started using Visualize with a Windows application, without using the MFC toolkit. This sample is relevant for customers who wish to handle input from the user using only Win32 calls. It supports loading HMF files, changing render modes, camera manipulation, simple geometry creation and selection.
Availability: Windows
How to Run: Win32 Simple
needs to be built before it can be run. Please see the next section for instructions on how to build it. Once it is built, it can be run as follows: Launch win32_simple.exe
from hoops_dir/bin/<platform>
How to Build:
win32_simple_v<version>
project and choose 'Build'Description: WPF Image
is a simple sandbox which showcases how to use HOOPS Visualize's C# API in a WPF application which makes use of D3DImage
. While there is a performance penalty for using D3DImage
, this workflow allows the superimposition of other WPF controls on top of the canvas. This approach is demonstrated in the sandbox, where all the buttons are WPF button elements floating over the canvas. This application allows the user to load files and to manipulate the camera, as well as toggling shadow visibility for the model. It is meant as a starting point for customers to prototype their applications. It uses the DirectX 11 driver by default.
Availability: Windows
How to Run: WPF Image needs to be built before it can be run. Please see the next section for instructions on how to build it. Once it is built, it can be run as follows: Launch wpf_image.exe
from hoops_dir/bin/<platform>
How to Build:
wpf_image_cs_v<version>.vcxproj
project, found at hoops_dir/demo/dotnet/wpf_image to the samples solutionwpf_image
project and choose 'Build'Description: Simple sandbox application built with the intent to show how to use the C# 3DF API together with WPF GUI toolkit. It allows users to load HSF and HMF files, create spheres, cones, cylinders and annotations. When the orbit operator is active, the camera can be orbited using the left mouse button, panned using the right mouse button, and zoomed using the mouse wheel. The scene can be sent to a printer, and the code shows how hardcopy support can be added to a C# application. It is meant as a starting point for customers to prototype their applications.
Availability: Windows only
How to Run: Launch wpf_simple.exe
from hoops_dir/bin/<platform>
How to Build:
wpf_simple
project and choose 'Build'