How to Create a vgPicker Instance

Vega Code Example

 

 

 

 

 

 
 

This example illustrates how to :

  • How to translate a picked vgObject
  • Create an instance of  vgPicker
  • How to use the trigger the vgPicker
  • How to retireve the results from a vgPicker
  • Shows a basic Vega  application

Keyboard Controls :

  • '1'  Set the translation plane to XY
  • '2'  Set the translation plane to XZ
  • '3'  Set the translation plane to YZ
  • '<'  Decrease the Time of day
  • '<'  Increase the Time of day
  • 's'  Display and cycle statistics
  • 'f'   Toggle Fog on and off
  • 't'   Toggle texturing on and off
  • 'w'  Toggle wire frame mode on and off

Keyboard Controls :

  • 'Left Button' Select and Un-select the vgObject under the cursor.
  • 'Right Button' Hold and Drag translates the selected vgObject

  •  This example does  require a simple ADF, such as simple.adf , esprit.adf etc.)

 

 
   
 

 

 
 
 
 
            
#include <stdlib.h>       //  definition of exit                                
#include "vg.h"           //  main include file for Vega         
#include "pf.h"           //  main include file for Performer    
#include "assert.h"       //  definition of assert    
 
#define UNTIL_THE_COWS_COME_HOME 1
 
vgPicker    *picker    = NULL;
vgObserver  *mainObs   = NULL;
vgChannel   *mainChan  = NULL;
vgEnv       *mainEnv   = NULL;
vgWindow    *mainWin   = NULL;
vgGfx       *mainGfx   = NULL;
vgScene     *mainScn   = NULL;
 
 
void  setSystemPointers();
void  createPicker();
void  userUpdates();
void  updateGFX( vgGfx *gfx, int what );
void  checkPickEvent();
 
 

void

checkPickEvent(){
// ###################################################
// # Local Function
// #
// # Check to see if a pick event has happpened
// # or if a transfomation is rquired
// #
// ###################################################

static
vgMouse mouse;

static  vgPosition *pos = NULL;

 

    if( pos == NULL ){

        pos = vgNewPos();

        assert( pos );

        }

    //
    // Retrieve the current mouse state
    //
vgGetMouse( &mouse );

 

    //

    // Left mouse pressed then do a pick action

    //

    if( mouse.lb && !mouse.mb && !mouse.rb ) {

        vgGetPos( obs, pos );

        vgPerformPickProcessing( picker, pos) ;

        }

 

    //
    //
Right mouse pressed then do a xform action this

   // will transform the picked object in the selected
    // plane while the right mouse is held down    

    //
    if
( !mouse.lb && !mouse.mb && mouse.rb ) {
        vgGetPos( obs, pos );

        

        vgPickerDoMouseTransform( picker, pos);

        }
 

} // checkPickEvent()

 
void
createPicker(){
//  ######################################## 
//  # Local Function            
//  #
//  #    Create an instance of vgPicker     
//  #
//  ######################################## 
 
    // 
    // Create the new Terrain picker 
    // 
    picker = vgNewPicker();
    assert( picker );
    
    vgName( picker, "example_picker" );
 
 
    // 
    // we use the default scene 0 and channel 0 
    // 
    vgPickerScene(   picker,  mainScn );
    vgPickerChannel( picker,  mainChan  );
 
    // 
    // Set the Pick highlight to Red
    // 
     vgPickerHighLightColor( picker, 1.0f, 0.0f, 0.0f );

    
vgProp( picker, VGPICK_TRANSFORM,     VGPICK_TRANSLATE  );
    vgProp( picker, VGPICK_TRANSCOORDS,    VGPICK_OBJECT_AXES );
    vgProp( picker, VGPICK_HL_LEVEL,       VGPICK_OBJECT      ); 
    vgProp( picker, VGPICK_HL_STYLE,       VGPICK_HL_LINE     );
    vgProp( picker, VGPICK_TERRAIN_CLAMP,  VG_OFF             );
    vgProp( picker, VGPICK_TRANSOVERRIDE,  VG_OFF             );
    vgProp( picker, VGPICK_DISPLAY_STDOUT, VG_OFF             ); 
    vgProp( picker, VGPICK_MULTIPLE_PICKS, VG_OFF             );
    vgProp( picker, VGPICK_AUTOTRANSFORM,  VG_OFF             );
    vgProp( picker, VGPICK_TRACKPLANE,     VGPICK_TRACK_XY    );
    vgProp( picker, VGPICK_AUTOTRACKPLANE, VG_OFF             );
    vgProp( picker, VGPICK_DRAG_FACTOR,    1.0f               );
    vgProp( picker, VGPICK_RENDER_ISECT,   VG_OFF             );
 
    // 
    // Set the Internal isector mask to ALL 
    // 
    vgPickerClampIsector( picker, 0x10000000 ); 
    vgPickerIsector(      picker, 0x10000000 );
 
    // 
    // We need to turn the vgPicker ON 
    // 
    vgProp( picker, VGCOMMON_ENABLED,  VG_ON );
 
} // createPicker()
 
 
void
setSystemPointers(){
//  ####################################################
//  # Local Function  
//  #    
//  # Set soem convinience pointers to the Vage sytems 
//  # components defined in the ADF this function must 
//  # be called after vgConfigSys() has been called       
//  #    
//  ####################################################
 
 
    mainWin = vgGetWin( 0 );
    assert(mainWin);
 
    mainObs = vgGetObserv( 0 );        
    assert(mainObs  );
 
    mainChan = vgGetObservChan( mainObs, 0 );
    assert(mainChan);
 
    mainGfx = vgGetObservGfx( mainObs );   
    assert(mainEnv);
 
    mainEnv = vgGetEnv( 0 );   
    assert(mainEnv);
 
    mainScn = vgGetScene(0);
    assert(mainScn);
 
 
} // setSystemPointers()
 
 
void
updateGFX( vgGfx *gfx, int what ){
//  ############################################ 
//  # Local Function                           
//  #    
//  #   Simply toggle the GFX passed property 
//  #    
//  ############################################
int state = 0;
    
 
    // 
    // Sanity check 
    // 
    if( gfx == NULL )
         return;
 
 
    state = (int)vgGetProp( gfx,  what );
 
    if( state )
        vgProp( gfx, what, VG_OFF );
    else
        vgProp( gfx, what, VG_ON );
 
} // updateGFX()
 
 
 
void
userUpdates( ) {
//  ############################################ 
//  # Local Function                           
//  #    
//  #   To process user keyboard input        
//  #    
//  ############################################ 
int          key   = 0;
static int   stats = 0;
static float tod   = 1.0;
static float first = 1;
   
 
    // 
    // First time through we need to 
    // retrieve the current time of day
    //
    if (first) {
        first = 0;
        tod   = vgGetProp( mainEnv, VGENV_TOD ); 
        }
    
 
    // 
    // Note that in windows the Queue is
    // contains only one character
    // 
    while( (key = vgGetWinKey( mainWin )) != 0 ) {
        
        switch( key ) {
                                            
            case '<':
                tod -= 0.01f;
                if( tod < 0.0 )
                    tod = 0.0;
                vgProp( mainEnv, VGENV_TOD, tod );
                break;      
                
            case '>':
                tod += 0.01f;
                if( tod > 1.0 )
                    tod = 1.0;
                vgProp( mainEnv, VGENV_TOD, tod );
                break;      
                
                            
            case 's':
                stats += 1;
                if( stats > VGCHAN_FILL + 1 )
                    stats = VGCHAN_STATSOFF;
                vgProp( mainChan, VGCHAN_STATSSEL, stats );
                break;      
                
            case 'f': updateGFX( mainGfx, VGGFX_FOG );       break;     
  
            case 't': updateGFX( mainGfx, VGGFX_TEXTURE );   break;                     
 
            case 'w': updateGFX( mainGfx, VGGFX_WIREFRAME ); break;     
 
 
            case '1':
                vgProp( picker, VGPICK_TRACKPLANEVGPICK_TRACK_XY );
                break;      
  
            case '2':
                vgProp( picker, VGPICK_TRACKPLANEVGPICK_TRACK_XZ );
                break;      
  
            case '3':
                vgProp( picker, VGPICK_TRACKPLANEVGPICK_TRACK_YZ );
                break;      
  
                       
            default: break;                 
 
            } //  switch
        } //  while 
 
} // userUpdates()
 
int
main(int argc, char* argv[]) {
 
 
    // 
    // This simple example requires that ADF configuration 
    // is passed on the command line
    // 
    if( argc < 2 ) {
        printf ( "usage: %s <ADF config file>\n", argv[0] );
        exit ( -1 );
        }
 
    // 
    // Vega must be first initialise
    //  
    vgInitSys();
 
     //
    // Next we defined the major Vega class instances by 
     // passing the name of an ADF file from the command line
     //
    vgDefineSys( argv[1] );
 
     //
    // Now create the class instance defined in the ADF
    // 
    vgConfigSys(); 
 
    // 
    // Grab some pointers to the classes created
    //  
    setSystemPointers();
 
    // 
    // Create and initialise our picker  
    // 
    createPicker();
 
    //
    // Quick and dirty, make ever object have its
    // isector mask set such that is can be picked
    //
 
    for( int  i= 0; i < vgGetNumObj(), i++ ){
 
        vgObject *obj     = vgGetObj(i);
        unsigned int mask = vgGetObjClass( obj );
        mask |= vgGetPickerIsector( picker );
        vgObjClass( obj, mask );
        }
 
 
    // 
    // Keep drawing until the default exit
    // key is pressed (ESC) or the windo closed
    // 
    while( true ) {
 
        vgSyncFrame();
        vgFrame();
        
        userUpdates();
        checkPickEvent();
        }
 
 
return 0;
}
 
 
 

 

 

Copyright 2004 Gordon Tomlinson  All Rights Reserved.

All logos, trademarks and copyrights in this site are property of their respective owner.