ChasmIntro_tut2

This is part of the ChasmIntro series.

The second introduction to Chasm deals with creating a world in SVE where the user points at an object, pushes a button and the object moves to a new location.

This section demonstrates how to solve a simple 3D interaction problem inside Chasm. The description of the problem is this: When the user selects the end object out of a line of objects with raycasting, have that object move to the center and above the other objects.

Before the selection

After the animation

Enter the Directory and Load the GUI

Go to the directory chasm/tutorials/tut2_move_object where you will find a Makefile, the tutorial2_base.C file and the directory answers which contains finished versions of the code. There are also files for SVE such as sve.init, termio.h and tut2.world.

• Set your CHASM_HOME variable to include the current directory.
  
  
• Open the chasmgui in the current directory.
  

Create the Concept with the GUI

Go through the following steps. Use the help button "?" as needed. Some of the descriptions are purposefully vague. If you become stuck, see the answers directory.

• Open the current directory as a package using the "Load Package" button and selecting, with the GUI's directory selector, tut2_move_object.
  
  
• Create a new Concept and call it Scenario_MoveObject and place the description into it of 'When the user selects the end object out of a line of objects with raycasting, have that object move to the center and above the other objects.'
  
  
• Since you know you are using RaycastingSelection and pointing at a certain object, create a protected component of RaycastingSelection, which is in the vocab directory, which is passed and called "raycasting".
  
  
• Open raycasting and review its states, symbols and components until you know how it works. Also, see its parent concept. Hide raycasting and then unhide it by clicking on it in the Component frame.
• Create a component WorldObject which is protected, passed and called "targetedobject".
  
  
• Since you are monitoring an object for selection, create a protected component concept of class MonitorObjectForSelection and call it "mfs". The intent is that it will enter the state selected when the targetedobject is selected by raycasting. You will call the static constructor of this concept later in the c++ code since you are setting the CIF to created.
  
  
• Create a note on mfs of MonitorObjectForSelection which states "Determines if the targeted object is selected" and place the note in a good position to be read.
  
  
• The intent of this concept is to make the targetedobject move when it is selected. We have already represented the targetedobject being selected with the MonitorObjectForSelection so now we need to create a protected animated translation concept to move the targetedobject. To do this, create a component concept of class AnimatePositionTranslation and call it "apt".
  
  
• Create a response from the mfs.selected state to the apt.animating symbol.
  
  
• Save the concept.
  
  
• Open the file Scenario_MoveObject.chasmxml to see what you created.
  
  

Set up the code

• Create a supplemental file and .C and .h file from the Scenario_MoveObject.chasmxml file. Do this by typing:

chasm2C -s Scenario_MoveObject

• Again, type the command:

chasm2C -s Scenario_MoveObject

Notice how it warns you that the Scenario_MoveObject_sup.h and .C and .h files exist. Chasm makes sure you do not overwrite your code files.

• Move the tutorial2_base.C file to tutorial2.C.

Implement the C++ Code

• You now need to add C++ code in the tutorial2.C. Open tutorial2.C in any editor you use, and follow the following steps.
  
  
• Let us create the Scenario_MoveObject Concept. First, include its header file by uncommenting the include.

#include "Scenario_MoveObject.chasm.h"

Notice this uses the .chasm.h version and not the .h version. The .chasm.h version (which you have not created yet) has had a preprocessing command (chasmprocess) run over the Scenario_MoveObject's .h and .C file using the information in the .chasmxml file to create the .chasm.h and .chasm.C files. These files hold information from the user's code and the Chasm structure and are overwritten constantly so do not modify them directly. Only modify the .C, .h and _sup.h files.

• Now, create an instance of Scenario_MoveObject so in the main function, add the declaration:

Scenario_MoveObject.chasm* scenario = NULL;

and before Chasm_InteractiveShell() function call, add the call to the static constructor:

scenario = Scenario_MoveObject::cScenario_MoveObject(
    raycasting, testcube[NUMCUBES-1]);

testcube is a WorldObject and wand and raycasting are the passed in Concepts to Scenario_MoveObject.

• Create these concepts, wand and raycasting, to pass in as well as ray, the WorldObject used to point in Raycasting. Declare them both:

Button* button;
Raycasting* raycasting;
WorldObject *wand,*ray;

and create instances of them:

wand = WorldObject::cWorldObject("wand",
                new WorldObjectBuilderSVE(
                SVE_loadObject("wand.obj","wand")));
SVE_attachToObject(SVE_findWorldObject("wand"),
                SVE_findWorldObject("SVE hand") );
ray = WorldObject::cWorldObject("ray",
                new WorldObjectBuilderSVE(
                SVE_loadObject("ray.obj","ray"),
                SVE_findWorldObject("SVE cursor")));

button = Button::cButton(new ButtonBuilderSVE(1));
raycasting = RaycastingSelection::cRaycastingSelection(10.,
                   s_selection,selectable,ray,
                   new RaycastingSelectionBuilderSVE());
CHASM::WHEN_state_THEN_symbol(raycasting,button->down,
                              raycasting->rechecking);

Much of this complexity deals with SVE calls and creating the SVE builders.

• Also, you need to create something which tells the Raycasting concept to check for a selection. Create a Button concept and response.

  Button* button;
  ...
  button = Button::cButton(new ButtonBuilderSVE(1));

Notice how Builders are used in the Concepts. Read about builders here. They allow the same concept to be implemented in different toolkits by abstracting their functionality in Chasm structures.

• Compile.

make

• Run

./tutorial2

Finish implementing the Concept

• Notice the error you receive.

Err: Scenario_MoveObject.C line(134) in builderInitialization:  ERROR: you did not set Component variable 'mfs' in Scenario_MoveObject_1

We have to implement the Component concepts in Scenario_MoveObject.

• Add the lines to the supplement file in the Constructor section:

setComponent("mfs",
      mfs = MonitorObjectForSelection::cMonitorObjectForSelection(
      _targetedobject,_raycasting));
setComponent("apt",
      apt = AnimatedPositionTranslation::cAnimatedPositionTranslation(
      -0.8,0.4,0.,5.,
      _targetedobject->pointAtPosition()));

Notice you do not need to include header files as this is done automatically for you. These components are created here because you told Chasm that the Concept was responsible for them by setting the CIF to created.

Also notice how "mfs" and "apt" are the names of the components you set using the Chasm GUI.

Running tutorial2

• Compile it again.
  
  
• Run it again.
  
  
• When you run 'tutorial2', you will see the world in front of you. Use the vtsve command 'cmd' to control the user.

To move the user head to a good position type: s 0 1.8 0 0 0 0

To move the hand, type:

t 2

s 0. 1.5 -.5 28. 0. 0.

Use the 'fly' command to move the wand and shift arrow keys to change the angle of the ray. When you are pointing at the last object (as per the image above), click the button using the command: b 1