Changeset 20938

Show
Ignore:
Timestamp:
11/20/07 19:35:59 (1 year ago)
Author:
patrick
Message:

Updated for Sonix 1.3.6. Roll the PyJuggler? version to 1.3.6.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • PyJuggler/trunk/ChangeLog

    r20497 r20938  
    11DATE        AUTHOR      CHANGE 
    22----------- ----------- ------------------------------------------------------- 
     3Nov-20-2007 patrick     Updated for Sonix 1.3.6 and newer. 
     4                        NEW VERSION: 1.3.6 
    35Jul-08-2007 patrick     Updated for VR Juggler 2.3.11. Usage of OpenGL, OpenSG, 
    46                        and OSG are now much cleaner. User code must import 

  • PyJuggler/trunk/configure.ac

    r20497 r20938  
    413413JCCL_PATH_CXX([1.1.11], , 
    414414              [AC_MSG_ERROR([*** JCCL is required for PyJuggler ***])]) 
    415 SNX_PATH([0.5.0], , [AC_MSG_ERROR([*** Sonix is required for PyJuggler ***])]) 
     415SNX_PATH([1.3.6], , [AC_MSG_ERROR([*** Sonix is required for PyJuggler ***])]) 
    416416GADGETEER_PATH([1.3.9], , 
    417417               [AC_MSG_ERROR([*** Gadgeteer is required for PyJuggler ***])]) 

  • PyJuggler/trunk/dist/__init__.py

    r20497 r20938  
    66__all__     = ["vrj", "cluster", "gadget", "snx", "jccl", "vpr"] 
    77__build__   = 1 
    8 __version__ = '1.3.5.%d' % __build__ 
     8__version__ = '1.3.6.%d' % __build__ 
    99__date__    = string.join(string.split('$Date$')[1:3], ' ') 
    1010__author__  = 'Patrick Hartling <patrick@infiscape.com>' 

  • PyJuggler/trunk/src/snx/_SoundHandle.cpp

    r19730 r20938  
    7777   } 
    7878 
    79    void trigger(const int& p0) 
     79   void trigger(const int p0) 
    8080   { 
    8181      try 
    …… 
    9696   } 
    9797 
    98    void default_trigger_0() 
    99    { 
    100       snx::SoundHandle::trigger(); 
    101    } 
    102  
    103    void default_trigger_1(const int& p0) 
     98   void default_trigger(const int p0) 
    10499   { 
    105100      snx::SoundHandle::trigger(p0); 
    …… 
    397392   } 
    398393 
    399    void setPosition(const float& p0, const float& p1, const float& p2) 
     394   void setPosition(const float p0, const float p1, const float p2) 
    400395   { 
    401396      try 
    …… 
    416411   } 
    417412 
    418    void default_setPosition(const float& p0, const float& p1, const float& p2) 
     413   void default_setPosition(const float p0, const float p1, const float p2) 
    419414   { 
    420415      snx::SoundHandle::setPosition(p0, p1, p2); 
    …… 
    589584      .def(init<const std::string&>()) 
    590585      .def("trigger", &snx::SoundHandle::trigger, 
    591            &pyj::snx_SoundHandle_Wrapper::default_trigger_1, 
    592            "trigger(repeat)\n" 
     586           &pyj::snx_SoundHandle_Wrapper::default_trigger, 
     587           (arg("repeat") = 1), 
     588           "trigger(repeat = 1)\n" 
    593589           "Triggers a sound.\n\n" 
    594590           "Pre-condition:\n" 
    …… 
    602598           "Triggers a sound once." 
    603599      ) 
    604       .def("trigger", &pyj::snx_SoundHandle_Wrapper::default_trigger_0) 
    605600      .def("isPlaying", &snx::SoundHandle::isPlaying, 
    606601           &pyj::snx_SoundHandle_Wrapper::default_isPlaying, 

  • PyJuggler/trunk/src/snx/_SoundImplementation.cpp

    r19730 r20938  
    7777   } 
    7878 
    79    void trigger(const std::string& p0, const int& p1) 
     79   void trigger(const std::string& p0, const int p1) 
    8080   { 
    8181      try 
    …… 
    9696   } 
    9797 
    98    void default_trigger_1(const std::string& p0) 
    99    { 
    100       snx::SoundImplementation::trigger(p0); 
    101    } 
    102  
    103    void default_trigger_2(const std::string& p0, const int& p1) 
     98   void default_trigger(const std::string& p0, const int p1) 
    10499   { 
    105100      snx::SoundImplementation::trigger(p0, p1); 
    …… 
    272267   } 
    273268 
    274    void setAmbient(const std::string& p0, bool p1) 
     269   void setAmbient(const std::string& p0, const bool p1) 
    275270   { 
    276271      try 
    …… 
    291286   } 
    292287 
    293    void default_setAmbient_1(const std::string& p0) 
    294    { 
    295       snx::SoundImplementation::setAmbient(p0); 
    296    } 
    297  
    298    void default_setAmbient_2(const std::string& p0, bool p1) 
     288   void default_setAmbient(const std::string& p0, const bool p1 = false) 
    299289   { 
    300290      snx::SoundImplementation::setAmbient(p0, p1); 
    301     } 
     291   } 
    302292 
    303293   bool isAmbient(const std::string& p0) 
    …… 
    617607   } 
    618608 
    619    void step(const float& p0) 
     609   void step(const float p0) 
    620610   { 
    621611      try 
    …… 
    636626   } 
    637627 
    638    void default_step(const float& p0) 
     628   void default_step(const float p0) 
    639629   { 
    640630      snx::SoundImplementation::step(p0); 
    …… 
    846836      ) 
    847837      .def("trigger", &snx::SoundImplementation::trigger, 
    848            &pyj::snx_SoundImplementation_Wrapper::default_trigger_2, 
    849            "trigger(alias, repeat)\n" 
     838           (arg("alias"), arg("repeat") = 1), 
     839           "trigger(alias, repeat = 1)\n" 
    850840           "Triggers a sound.\n\n" 
    851841           "Pre-condition:\n" 
    …… 
    857847           "alias  -- Alias of the sound to trigger.\n" 
    858848           "repeat -- The number of times to play.  Use -1 to repeat\n\n" 
    859            "          forever.\n\n" 
    860            "trigger(alias)\n" 
    861            "Triggers a sound once." 
    862       ) 
    863       .def("trigger", &pyj::snx_SoundImplementation_Wrapper::default_trigger_1 
     849           "          forever.  The default is to play the sound once.\n\n" 
    864850      ) 
    865851      .def("isPlaying", &snx::SoundImplementation::isPlaying, 
    …… 
    919905      ) 
    920906      .def("setAmbient", &snx::SoundImplementation::setAmbient, 
    921            &pyj::snx_SoundImplementation_Wrapper::default_setAmbient_2, 
    922            "setAmbient(alias, ambient)\n" 
     907           &pyj::snx_SoundImplementation_Wrapper::default_setAmbient, 
     908           "setAmbient(alias, ambient = False)\n" 
    923909           "Sets the named sound as either ambient or positional depending\n" 
    924910           "on the value of the given argument.  If the sound is ambient,\n" 
    …… 
    930916           "ambient -- A Boolean flag identifying whether this sound is\n" 
    931917           "           ambient (True) or positional (False).\n\n" 
    932            "setAmbient(alias)\n" 
    933            "Sets the sound as being positional.\n\n" 
    934            "Arguments:\n" 
    935            "alias -- The alias of the sound to change\n" 
    936       ) 
    937       .def("setAmbient", 
    938            &pyj::snx_SoundImplementation_Wrapper::default_setAmbient_1 
    939918      ) 
    940919      .def("isAmbient", &snx::SoundImplementation::isAmbient, 

  • PyJuggler/trunk/src/snx/_sonix.cpp

    r19730 r20938  
    1313using namespace boost::python; 
    1414 
    15 // Declarations ================================================================ 
     15// Declarations =============================================================== 
     16 
    1617namespace pyj 
    1718{ 
    1819 
    19 struct snx_sonix_Adapter : snx::sonix 
     20tuple getPositionWrapper(const std::string& alias) 
    2021{ 
    21    snx_sonix_Adapter(const snx::sonix& p0) 
    22       : snx::sonix(p0) 
    23    { 
    24       /* Do nothing. */ ; 
    25    } 
    26  
    27    virtual ~snx_sonix_Adapter() 
    28    { 
    29       /* Do nothing. */ ; 
    30    } 
    31  
    32    virtual tuple getPositionWrapper(const std::string& alias) 
    33    { 
    34       float p0, p1, p2; 
    35       snx::sonix::getPosition(alias, p0, p1, p2); 
    36       return make_tuple(p0, p1, p2); 
    37    } 
    38 }; 
    39  
    40 struct snx_sonix_Wrapper : snx_sonix_Adapter, wrapper<snx_sonix_Adapter> 
    41 { 
    42    snx_sonix_Wrapper(const snx::sonix& p0) 
    43       : snx_sonix_Adapter(p0) 
    44    { 
    45       /* Do nothing. */ ; 
    46    } 
    47  
    48    virtual ~snx_sonix_Wrapper() 
    49    { 
    50       /* Do nothing. */ ; 
    51    } 
    52  
    53    void trigger(const std::string& p0, const int& p1) 
    54    { 
    55       try 
    56       { 
    57          if ( override trigger = this->get_override("trigger") ) 
    58          { 
    59             trigger(boost::ref(p0), p1); 
    60          } 
    61          else 
    62          { 
    63             snx::sonix::trigger(p0, p1); 
    64          } 
    65       } 
    66       catch (error_already_set) 
    67       { 
    68          PyErr_Print(); 
    69       } 
    70    } 
    71  
    72    void default_trigger_1(const std::string& p0) 
    73    { 
    74       snx::sonix::trigger(p0); 
    75    } 
    76  
    77    void default_trigger_2(const std::string& p0, const int& p1) 
    78    { 
    79       snx::sonix::trigger(p0, p1); 
    80    } 
    81  
    82    bool isPlaying(const std::string& p0) 
    83    { 
    84       try 
    85       { 
    86          if ( override isPlaying = this->get_override("isPlaying") ) 
    87          { 
    88             return isPlaying(boost::ref(p0)); 
    89          } 
    90          return snx::sonix::isPlaying(p0); 
    91       } 
    92       catch (error_already_set) 
    93       { 
    94          PyErr_Print(); 
    95       } 
    96    } 
    97  
    98    bool default_isPlaying(const std::string& p0) 
    99    { 
    100       return snx::sonix::isPlaying(p0); 
    101    } 
    102  
    103    void setRetriggerable(const std::string& p0, bool p1) 
    104    { 
    105       try 
    106       { 
    107          if ( override setRetriggerable = 
    108                  this->get_override("setRetriggerable") ) 
    109          { 
    110             setRetriggerable(boost::ref(p0), p1); 
    111          } 
    112          else 
    113          { 
    114             snx::sonix::setRetriggerable(p0, p1); 
    115          } 
    116       } 
    117       catch (error_already_set) 
    118       { 
    119          PyErr_Print(); 
    120       } 
    121    } 
    122  
    123    void default_setRetriggerable(const std::string& p0, bool p1) 
    124    { 
    125       snx::sonix::setRetriggerable(p0, p1); 
    126    } 
    127  
    128    bool isRetriggerable(const std::string& p0) 
    129    { 
    130       try 
    131       { 
    132          if ( override isRetriggerable = 
    133                  this->get_override("isRetriggerable") ) 
    134          { 
    135             return isRetriggerable(boost::ref(p0)); 
    136          } 
    137          return snx::sonix::isRetriggerable(p0); 
    138       } 
    139       catch (error_already_set) 
    140       { 
    141          PyErr_Print(); 
    142       } 
    143    } 
    144  
    145    bool default_isRetriggerable(const std::string& p0) 
    146    { 
    147       return snx::sonix::isRetriggerable(p0); 
    148    } 
    149  
    150    void stop(const std::string& p0) 
    151    { 
    152       try 
    153       { 
    154          if ( override stop = this->get_override("stop") ) 
    155          { 
    156             stop(boost::ref(p0)); 
    157          } 
    158          else 
    159          { 
    160             snx::sonix::stop(p0); 
    161          } 
    162       } 
    163       catch (error_already_set) 
    164       { 
    165          PyErr_Print(); 
    166       } 
    167    } 
    168  
    169    void default_stop(const std::string& p0) 
    170    { 
    171       snx::sonix::stop(p0); 
    172    } 
    173  
    174    void pause(const std::string& p0) 
    175    { 
    176       try 
    177       { 
    178          if ( override pause = this->get_override("pause") ) 
    179          { 
    180             pause(boost::ref(p0)); 
    181          } 
    182          else 
    183          { 
    184             snx::sonix::pause(p0); 
    185          } 
    186       } 
    187       catch (error_already_set) 
    188       { 
    189          PyErr_Print(); 
    190       } 
    191    } 
    192  
    193    void default_pause(const std::string& p0) 
    194    { 
    195       snx::sonix::pause(p0); 
    196    } 
    197  
    198    void unpause(const std::string& p0) 
    199    { 
    200       try 
    201       { 
    202          if ( override unpause = this->get_override("unpause") ) 
    203          { 
    204             unpause(boost::ref(p0)); 
    205          } 
    206          else 
    207          { 
    208             snx::sonix::unpause(p0); 
    209          } 
    210       } 
    211       catch (error_already_set) 
    212       { 
    213          PyErr_Print(); 
    214       } 
    215    } 
    216  
    217    void default_unpause(const std::string& p0) 
    218    { 
    219       snx::sonix::unpause(p0); 
    220    } 
    221  
    222    bool isPaused(const std::string& p0) 
    223    { 
    224       try 
    225       { 
    226          if ( override isPaused = this->get_override("isPaused") ) 
    227          { 
    228             return isPaused(boost::ref(p0)); 
    229          } 
    230          return snx::sonix::isPaused(p0); 
    231       } 
    232       catch (error_already_set) 
    233       { 
    234          PyErr_Print(); 
    235       } 
    236    } 
    237  
    238    bool default_isPaused(const std::string& p0) 
    239    { 
    240       return snx::sonix::isPaused(p0); 
    241    } 
    242  
    243    void setAmbient(const std::string& p0, const bool p1) 
    244    { 
    245       try 
    246       { 
    247          if ( override setAmbient = this->get_override("setAmbient") ) 
    248          { 
    249             setAmbient(boost::ref(p0), p1); 
    250          } 
    251          else 
    252          { 
    253             snx::sonix::setAmbient(p0, p1); 
    254          } 
    255       } 
    256       catch (error_already_set) 
    257       { 
    258          PyErr_Print(); 
    259       } 
    260    } 
    261  
    262    void default_setAmbient_1(const std::string& p0) 
    263    { 
    264       snx::sonix::setAmbient(p0); 
    265    } 
    266  
    267    void default_setAmbient_2(const std::string& p0, const bool p1) 
    268    { 
    269       snx::sonix::setAmbient(p0, p1); 
    270    } 
    271  
    272    bool isAmbient(const std::string& p0) 
    273    { 
    274       try 
    275       { 
    276          if ( override isAmbient = this->get_override("isAmbient") ) 
    277          { 
    278             return isAmbient(boost::ref(p0)); 
    279          } 
    280          return snx::sonix::isAmbient(p0); 
    281       } 
    282       catch (error_already_set) 
    283       { 
    284          PyErr_Print(); 
    285       } 
    286  
    287       return false; 
    288    } 
    289  
    290    bool default_isAmbient(const std::string& p0) 
    291    { 
    292       return snx::sonix::isAmbient(p0); 
    293    } 
    294  
    295    void setPitchBend(const std::string& p0, float p1) 
    296    { 
    297       try 
    298       { 
    299          if ( override setPitchBend = this->get_override("setPitchBend") ) 
    300          { 
    301             setPitchBend(boost::ref(p0), p1); 
    302          } 
    303          else 
    304          { 
    305             snx::sonix::setPitchBend(p0, p1); 
    306          } 
    307       } 
    308       catch (error_already_set) 
    309       { 
    310          PyErr_Print(); 
    311       } 
    312    } 
    313  
    314    void default_setPitchBend(const std::string& p0, float p1) 
    315    { 
    316       snx::sonix::setPitchBend(p0, p1); 
    317    } 
    318  
    319    void setVolume(const std::string& p0, float p1) 
    320    { 
    321       try 
    322       { 
    323          if ( override setVolume = this->get_override("setVolume") ) 
    324          { 
    325             setVolume(boost::ref(p0), p1); 
    326          } 
    327          else 
    328          { 
    329             snx::sonix::setVolume(p0, p1); 
    330          } 
    331       } 
    332       catch (error_already_set) 
    333       { 
    334          PyErr_Print(); 
    335       } 
    336    } 
    337  
    338    void default_setVolume(const std::string& p0, float p1) 
    339    { 
    340       snx::sonix::setVolume(p0, p1); 
    341    } 
    342  
    343    void setCutoff(const std::string& p0, float p1) 
    344    { 
    345       try 
    346       { 
    347          if ( override setCutoff = this->get_override("setCutoff") ) 
    348          { 
    349             setCutoff(boost::ref(p0), p1); 
    350          } 
    351          else 
    352          { 
    353             snx::sonix::setCutoff(p0, p1); 
    354          } 
    355       } 
    356       catch (error_already_set) 
    357       { 
    358          PyErr_Print(); 
    359       } 
    360    } 
    361  
    362    void default_setCutoff(const std::string& p0, float p1) 
    363    { 
    364       snx::sonix::setCutoff(p0, p1); 
    365    } 
    366  
    367    void setPosition(const std::string& p0, const float& p1, const float& p2, 
    368                     const float& p3) 
    369    { 
    370       try 
    371       { 
    372          if ( override setPosition = this->get_override("setPosition") ) 
    373          { 
    374             setPosition(boost::ref(p0), p1, p2, p3); 
    375          } 
    376          else 
    377          { 
    378             snx::sonix::setPosition(p0, p1, p2, p3); 
    379          } 
    380       } 
    381       catch (error_already_set) 
    382       { 
    383          PyErr_Print(); 
    384       } 
    385    } 
    386  
    387    void default_setPosition(const std::string& p0, const float& p1, 
    388                             const float& p2, const float& p3) 
    389    { 
    390       snx::sonix::setPosition(p0, p1, p2, p3); 
    391    } 
    392  
    393    void getPosition(const std::string& p0, float& p1, float& p2, float& p3) 
    394    { 
    395       tuple result = getPositionWrapper(p0); 
    396       p1 = extract<float>(result[0]); 
    397       p2 = extract<float>(result[1]); 
    398       p3 = extract<float>(result[2]); 
    399    } 
    400  
    401    tuple getPositionWrapper(const std::string& p0) 
    402    { 
    403       try 
    404       { 
    405          if ( override getPosition = this->get_override("getPosition") ) 
    406          { 
    407             return getPosition(boost::ref(p0)); 
    408          } 
    409          return snx_sonix_Adapter::getPositionWrapper(p0); 
    410       } 
    411       catch (error_already_set) 
    412       { 
    413          PyErr_Print(); 
    414       } 
    415  
    416       return make_tuple(); 
    417    } 
    418  
    419    tuple default_getPositionWrapper(const std::string& p0) 
    420    { 
    421       return snx_sonix_Adapter::getPositionWrapper(p0); 
    422    } 
    423  
    424    void setListenerPosition(const gmtl::Matrix44f& p0) 
    425    { 
    426       try 
    427       { 
    428          if ( override setListenerPosition = 
    429                  this->get_override("setListenerPosition") ) 
    430          { 
    431             setListenerPosition(boost::ref(p0)); 
    432          } 
    433          else 
    434          { 
    435             snx::sonix::setListenerPosition(p0); 
    436          } 
    437       } 
    438       catch (error_already_set) 
    439       { 
    440          PyErr_Print(); 
    441       } 
    442    } 
    443  
    444    void default_setListenerPosition(const gmtl::Matrix44f& p0) 
    445    { 
    446       snx::sonix::setListenerPosition(p0); 
    447    } 
    448  
    449    void getListenerPosition(gmtl::Matrix44f& p0) 
    450    { 
    451       try 
    452       { 
    453          if ( override getListenerPosition = 
    454                  this->get_override("getListenerPosition") ) 
    455          { 
    456             getListenerPosition(p0); 
    457          } 
    458          else 
    459          { 
    460             snx::sonix::getListenerPosition(p0); 
    461          } 
    462       } 
    463       catch (error_already_set) 
    464       { 
    465          PyErr_Print(); 
    466       } 
    467    } 
    468  
    469    void default_getListenerPosition(gmtl::Matrix44f& p0) 
    470    { 
    471       snx::sonix::getListenerPosition(p0); 
    472    } 
    473  
    474    void changeAPI(const std::string& p0) 
    475    { 
    476       try 
    477       { 
    478          if ( override changeAPI = this->get_override("changeAPI") ) 
    479          { 
    480             changeAPI(boost::ref(p0)); 
    481          } 
    482          else 
    483          { 
    484             snx::sonix::changeAPI(p0); 
    485          } 
    486       } 
    487       catch (error_already_set) 
    488       { 
    489          PyErr_Print(); 
    490       } 
    491    } 
    492  
    493    void default_changeAPI(const std::string& p0) 
    494    { 
    495       snx::sonix::changeAPI(p0); 
    496    } 
    497  
    498    void configure(const snx::SoundAPIInfo& p0) 
    499    { 
    500       try 
    501       { 
    502          if ( override configure = this->get_override("configure") ) 
    503          { 
    504             configure(boost::ref(p0)); 
    505          } 
    506          else 
    507          { 
    508             snx::sonix::configure(p0); 
    509          } 
    510       } 
    511       catch (error_already_set) 
    512       { 
    513          PyErr_Print(); 
    514       } 
    515    } 
    516  
    517    void default_configure(const snx::SoundAPIInfo& p0) 
    518    { 
    519       snx::sonix::configure(p0); 
    520    } 
    521  
    522    void configure(const std::string& p0, const snx::SoundInfo& p1) 
    523    { 
    524       try 
    525       { 
    526          if ( override configure = this->get_override("configure") ) 
    527          { 
    528             configure(boost::ref(p0), p1); 
    529          } 
    530          else 
    531          { 
    532             snx::sonix::configure(p0, p1); 
    533          } 
    534       } 
    535       catch (error_already_set) 
    536       { 
    537          PyErr_Print(); 
    538       } 
    539    } 
    540  
    541    void default_configure(const std::string& p0, const snx::SoundInfo& p1) 
    542    { 
    543       snx::sonix::configure(p0, p1); 
    544    } 
    545  
    546    void remove(const std::string p0) 
    547    { 
    548       try 
    549       { 
    550          if ( override remove = this->get_override("remove") ) 
    551          { 
    552             remove(boost::ref(p0)); 
    553          } 
    554          else 
    555          { 
    556             snx::sonix::remove(p0); 
    557          } 
    558       } 
    559       catch (error_already_set) 
    560       { 
    561          PyErr_Print(); 
    562       } 
    563    } 
    564  
    565    void default_remove(const std::string p0) 
    566    { 
    567       snx::sonix::remove(p0); 
    568    } 
    569  
    570    void step(const float& p0) 
    571    { 
    572       try 
    573       { 
    574          if ( override step = this->get_override("step") ) 
    575          { 
    576             step(p0); 
    577          } 
    578          else 
    579          { 
    580             snx::sonix::step(p0); 
    581          } 
    582       } 
    583       catch (error_already_set) 
    584       { 
    585          PyErr_Print(); 
    586       } 
    587    } 
    588  
    589    void default_step(const float& p0) 
    590    { 
    591       snx::sonix::step(p0); 
    592    } 
    593  
    594    PyObject* self; 
    595 }; 
    596  
    597  
    598 }// namespace pyj 
    599  
     22   float p0, p1, p2; 
     23   snx::sonix::instance()->getPosition(alias, p0, p1, p2); 
     24   return make_tuple(p0, p1, p2); 
     25} 
     26 
     27} 
    60028 
    60129// Module ====================================================================== 
    60230void _Export_sonix() 
    60331{ 
    604    class_<pyj::snx_sonix_Wrapper, boost::noncopyable>("sonix", no_init) 
     32   class_<snx::sonix, boost::noncopyable>("sonix", no_init) 
    60533      .def("trigger", &snx::sonix::trigger, 
    606            &pyj::snx_sonix_Wrapper::default_trigger_2, 
    607            "trigger(alias, repeat)\n" 
     34           (arg("alias"), arg("repeat") = 1), 
     35           "trigger(alias, repeat = 1)\n" 
    60836           "Triggers a sound.\n\n" 
    60937           "Pre-condition:\n" 
    …… 
    61543           "alias  -- Alias of the sound to trigger.\n" 
    61644           "repeat -- The number of times to play.  Use -1 to repeat\n\n" 
    617            "          forever.\n\n" 
    618            "trigger(alias)\n" 
    619            "Triggers a sound once." 
    620       ) 
    621       .def("trigger", &pyj::snx_sonix_Wrapper::default_trigger_1) 
     45           "          forever.  The default is to trigger the sound once." 
     46      ) 
    62247      .def("isPlaying", &snx::sonix::isPlaying, 
    623            &pyj::snx_sonix_Wrapper::default_isPlaying, 
    62448           "isPlaying(alias) -> Boolean\n" 
    62549           "Is the named sound currently playing?\n\n" 
    …… 
    62852      ) 
    62953      .def("setRetriggerable", &snx::sonix::setRetriggerable, 
    630            &pyj::snx_sonix_Wrapper::default_setRetriggerable, 
    63154           "setRetriggerable(alias, onOff)\n" 
    63255           "Specifies whether the named sound retriggers from the beginning\n" 
    …… 
    63962      ) 
    64063      .def("isRetriggerable", &snx::sonix::isRetriggerable, 
    641            &pyj::snx_sonix_Wrapper::default_isRetriggerable, 
    64264           "isRetriggerable(alais) -> Boolean\n" 
    64365           "Is the named sound retriggerable?\n\n" 
    …… 
    64567           "alias -- The alias of the sound to query." 
    64668      ) 
    647       .def("stop", &snx::sonix::stop, &pyj::snx_sonix_Wrapper::default_stop, 
     69      .def("stop", &snx::sonix::stop, 
    64870           "stop(alias)\n" 
    64971           "Stops the named sound.\n\n" 
    …… 
    65274      ) 
    65375      .def("pause", &snx::sonix::pause, 
    654            &pyj::snx_sonix_Wrapper::default_pause, 
    65576           "pause(alias)\n" 
    65677           "Pauses the sound.  Use unpause() to return playback from where\n" 
    …… 
    66081      ) 
    66182      .def("unpause", &snx::sonix::unpause, 
    662            &pyj::snx_sonix_Wrapper::default_unpause, 
    66383           "unpause(alias)\n" 
    66484           "Resumes playback of the named sound from a paused state.  This\n" 
    …… 
    66888      ) 
    66989      .def("isPaused", &snx::sonix::isPaused, 
    670            &pyj::snx_sonix_Wrapper::default_isPaused, 
    67190           "isPaused(alias) -> Boolean\n" 
    67291           "If the sound is paused, then return True.\n\n" 
    …… 
    67594      ) 
    67695      .def("setAmbient", &snx::sonix::setAmbient, 
    677            &pyj::snx_sonix_Wrapper::default_setAmbient_2, 
    678            "setAmbient(alias, ambient)\n" 
     96           (arg("alias"), arg("ambient") = false), 
     97           "setAmbient(alias, ambient = False)\n" 
    67998           "Sets the named sound as either ambient or positional depending\n" 
    68099           "on the value of the given argument.  If the sound is ambient,\n" 
    …… 
    685104           "alias   -- The alias of the sound to change\n" 
    686105           "ambient -- A Boolean flag identifying whether this sound is\n" 
    687            "           ambient (True) or positional (False).\n\n" 
    688            "setAmbient(alias)\n" 
    689            "Sets the sound as being positional.\n\n" 
    690            "Arguments:\n" 
    691            "alias -- The alias of the sound to change\n" 
    692       ) 
    693       .def("setAmbient", &pyj::snx_sonix_Wrapper::default_setAmbient_1) 
     106           "           ambient (True) or positional (False).  The default is\n" 
     107           "           positional." 
     108      ) 
    694109      .def("isAmbient", &snx::sonix::isAmbient, 
    695            &pyj::snx_sonix_Wrapper::default_isAmbient, 
    696110           "isAmbient(alias) -> Boolean\n" 
    697111           "Is the named sound ambient?\n\n" 
    …… 
    700114      ) 
    701115      .def("setPitchBend", &snx::sonix::setPitchBend, 
    702            &pyj::snx_sonix_Wrapper::default_setPitchBend, 
    703116           "setPitchBend(alias, amount)\n" 
    704117           "Alters the frequency of the named sound.\n\n" 
    …… 
    711124      ) 
    712125      .def("setVolume", &snx::sonix::setVolume, 
    713            &pyj::snx_sonix_Wrapper::default_setVolume, 
    714126           "setVolume(alias, amount)\n" 
    715127           "Sets the effect volume of the named sound.  The value must be\n" 
    …… 
    721133      ) 
    722134      .def("setCutoff", &snx::sonix::setCutoff, 
    723            &pyj::snx_sonix_Wrapper::default_setCutoff, 
    724135           "setCutoff(alias, amount)\n" 
    725136           "Sets the effect cutoff of the named sound.  Set to a value in\n" 
    …… 
    732143      ) 
    733144      .def("setPosition", &snx::sonix::setPosition, 
    734            &pyj::snx_sonix_Wrapper::default_setPosition, 
    735145           "setPosition(alias, x, y, z)\n" 
    736146           "Sets the named sound's three-dimensional position.\n\n" 
    …… 
    741151           "z     -- The Z coordinate of the sound in 3D OpenGL coordinates." 
    742152      ) 
    743       .def("getPosition", &pyj::snx_sonix_Adapter::getPositionWrapper, 
    744            &pyj::snx_sonix_Wrapper::default_getPositionWrapper, 
     153      .def("getPosition", &pyj::getPositionWrapper, 
    745154           "getPosition(alias) -> tuple\n" 
    746155           "Gets the named sound's 3D position.\n\n" 
    …… 
    752161      ) 
    753162      .def("setListenerPosition", &snx::sonix::setListenerPosition, 
    754            &pyj::snx_sonix_Wrapper::default_setListenerPosition, 
    755163           "setListenerPosition(matrix)\n" 
    756164           "Sets the position of the listener.\n\n" 
    …… 
    760168      ) 
    761169      .def("getListenerPosition", &snx::sonix::getListenerPosition, 
    762            &pyj::snx_sonix_Wrapper::default_getListenerPosition, 
    763170           "getListenerPosition(matrix)\n" 
    764171           "Gets the listeners's 3D position.\n\n" 
    …… 
    768175      ) 
    769176      .def("changeAPI", &snx::sonix::changeAPI, 
    770            &pyj::snx_sonix_Wrapper::default_changeAPI, 
    771177           "changeAPI(apiName)\n" 
    772178           "Changes the underlying sound API to something else.  This\n" 
    …… 
    785191      .def("configure", 
    786192           (void (snx::sonix::*)(const snx::SoundAPIInfo&)) &snx::sonix::configure, 
    787            (void (pyj::snx_sonix_Wrapper::*)(const snx::SoundAPIInfo&)) &pyj::snx_sonix_Wrapper::default_configure, 
    788193           "configure(description)\n" 
    789194           "Configures/reconfigures the sound API global settings.\n\n" 
    …… 
    794199      .def("configure", 
    795200           (void (snx::sonix::*)(const std::string&, const snx::SoundInfo&)) &snx::sonix::configure, 
    796            (void (pyj::snx_sonix_Wrapper::*)(const std::string&, const snx::SoundInfo&)) &pyj::snx_sonix_Wrapper::default_configure, 
    797201           "configure(alais, description)\n" 
    798202           "Configures/reconfigures the named sound by associating sound\n" 
    …… 
    814218      ) 
    815219      .def("remove", &snx::sonix::remove, 
    816            &pyj::snx_sonix_Wrapper::default_remove, 
    817220           "remove(alias)\n" 
    818221           "Removes a configured sound.  Any future reference to the alias\n" 
    …… 
    822225           "alias -- The alias of the sound to remove." 
    823226      ) 
    824       .def("step", &snx::sonix::step, &pyj::snx_sonix_Wrapper::default_step, 
     227      .def("step", &snx::sonix::step, 
    825228           "step(timeElapsed)\n" 
    826229           "Call once per sound frame (which does not have to be the same\n"