std::unique_ptr<l1menu::ITrigger> l1menu::TriggerTable::getTrigger( const std::string& name, unsigned int version ) const
{
TriggerDetails requestedTriggerDetails{ name, version };
// Delegate to the other overload
return getTrigger( requestedTriggerDetails );
}
bool DialogCommand::triggerPrivate(int *state)
{
Q_UNUSED(state);
bool succ = true;
kDebug() << "Triggering...";
if (m_executeCommands)
{
for (int i=0; i < m_commands.count(); i++)
succ = ActionManager::getInstance()->triggerCommand(m_commandTypes[i], m_commands[i]) && succ;
}
if (!state)
{
kDebug() << "Not given any state... Calling this on the parent...";
Command::parent()->switchToState(switchToState);
kDebug() << "My switch to state of " << getTrigger() << " is " << switchToState;
}
if (m_changeDialogState) {
kDebug() << "Changing dialog state to: " << m_nextDialogState;
emit requestDialogState(m_nextDialogState);
} else
kDebug() << "Not changing dialog state.";
return succ;
}
void TextEditorWindow::addTrigger(int typ)
{
if (!getTrigger())
{
Trigger* trig=new Trigger(typ);
((EditorComponent*)getContentComponent())->setTrigger(trig);
}
}
// ----------------------------------------------------------------------------
//
bool ChaseTask::followBeat( unsigned start_freq, unsigned end_freq ) {
if ( m_beat_detector != NULL ) {
m_beat_detector->detach();
delete m_beat_detector;
}
m_beat_detector = new BeatDetector( 64 );
m_beat_detector->attach( m_venue->getAudio() );
m_beat_detector->addFrequencyEvent( getTrigger(), start_freq, end_freq );
return true;
}
void TextEditorWindow::exportTrigger()
{
if (hasTrigger())
{
TextBuffer* buf=getTextBuffer();
String str=T("\n; ");
str<<getTrigger()->toXml() << T("\n");
buf->insertTextAtCursor(str);
buf->colorizeAfterChange(CommandIDs::EditorPaste);
buf->setFlag(EditFlags::NeedsSave);
}
}
void JsBase::jsBaseTickAxis(){
// Standerdize ALL joysticks
axis->trigger = getTrigger();
axis->ls_x = js->GetRawAxis(1);
axis->ls_y = -js->GetRawAxis(2);
axis->rs_x = js->GetRawAxis(4);
axis->rs_y = js->GetRawAxis(5);
axis->dpad_x = js->GetRawAxis(6);
// axis->dpad_y = js->GetRawAxis(0);
axis->dpad_y = 0.0;
}
std::unique_ptr<l1menu::ITrigger> l1menu::TriggerTable::copyTrigger( const l1menu::ITrigger& triggerToCopy ) const
{
// First create a trigger with the matching name and version
std::unique_ptr<l1menu::ITrigger> newTrigger=getTrigger( triggerToCopy.name(), triggerToCopy.version() );
if( newTrigger.get()==NULL ) throw std::runtime_error( "Unable to copy trigger "+triggerToCopy.name() );
//
// Now copy all of the parameters over.
//
// Get the parameter names
std::vector<std::string> parameterNames=triggerToCopy.parameterNames();
// Then run through and copy the value of each one
for( std::vector<std::string>::const_iterator iName=parameterNames.begin(); iName!=parameterNames.end(); ++iName )
{
newTrigger->parameter(*iName)=triggerToCopy.parameter(*iName);
}
return newTrigger;
}
void XboxInput::handleEvent(const sf::Event& e) {
switch(e.type) {
case sf::Event::JoystickButtonPressed:
{
XboxButton::Button b = static_cast<XboxButton::Button>(e.joystickButton.button);
state[e.joystickButton.joystickId].buttons[b] = true;
}
break;
case sf::Event::JoystickButtonReleased:
{
XboxButton::Button b = static_cast<XboxButton::Button>(e.joystickButton.button);
state[e.joystickButton.joystickId].buttons[b] = false;
}
break;
case sf::Event::JoystickMoved:
{
XboxAxis::Axis b = getAxis(e.joystickMove);
if(b != XboxAxis::None) {
float p = e.joystickMove.position/100.f;
if(std::fabs(e.joystickMove.position) < 20.f)
p = 0.f;
if(e.joystickMove.axis % 2 == 0)
state[e.joystickMove.joystickId].axis[b].x = p;
else
state[e.joystickMove.joystickId].axis[b].y = p;
} else {
XboxTrigger::Trigger t = getTrigger(e.joystickMove);
float p = (e.joystickMove.position+100.f)/200.f;
if(t != XboxTrigger::None)
state[e.joystickButton.joystickId].triggers[t] = std::fabs(p);
}
}
break;
default:
break;
}
}
static int
GPIO_set_trigger(GPIO *self, PyObject *val, void *closure)
{
char * trigger;
char cdir;
if (val == NULL) {
PyErr_SetString(PyExc_TypeError,
"Cannot delete attribute");
return -1;
}
if ( setTrigger(self, val) == NULL )
return -1;
if ( PyObject_Compare(val, getTrigger( self ) ) != 0 ) {
PyErr_SetString(PyExc_IOError, "setting trigger failed");
return -1;
}
self->trigger = val;
return 0;
}
GuiTune::GuiTune(QWidget *parent, int argc, char **argv) : QWidget(parent), audio(NULL)
{
int sampnr;
double sampfreq;
KAMMERTON = KAMMERTON_NORM;
KAMMERTON_LOG = KAMMERTON_LOG_NORM;
sampnr = 1024;
sampfreq = 11048;
CurrentDriver = OSSDriver;
audio = new AudioOSS(QString("/dev/dsp"));
audio->init_audio();
oszi = new OsziView(parent);
audio->setSampleFreq(sampfreq);
oszi->setSampleFreq(sampfreq);
audio->setSampleNr(sampnr);
oszi->setSampleNr(sampnr);
logview = new LogView(parent);
logview->setFrameStyle(QFrame::Box | QFrame::Sunken);
logview->setLineWidth(2);
freqview = new QLCDNumber(parent);
freqview->setDigitCount(9);
freqview->setFrameStyle(QFrame::NoFrame);
freqview->setSegmentStyle(QLCDNumber::Filled);
QLabel* freqviewLabel = new QLabel(tr("Freq.:"), parent);
freqviewLabel->setBuddy(freqview);
QHBoxLayout* freqviewLayout = new QHBoxLayout(this);
QWidget* freqviewWidget = new QWidget(parent);
freqviewLayout->addWidget(freqviewLabel);
freqviewLayout->addWidget(freqview);
freqviewWidget->setLayout(freqviewLayout);
nfreqview = new QLCDNumber(parent);
nfreqview->setDigitCount(9);
nfreqview->setFrameStyle(QFrame::NoFrame);
nfreqview->setSegmentStyle(QLCDNumber::Filled);
QLabel* nfreqviewLabel = new QLabel(tr("Note:"), parent);
nfreqviewLabel->setBuddy(nfreqview);
QHBoxLayout* nfreqviewLayout = new QHBoxLayout(this);
QWidget* nfreqviewWidget = new QWidget(parent);
nfreqviewLayout->addWidget(nfreqviewLabel);
nfreqviewLayout->addWidget(nfreqview);
nfreqviewWidget->setLayout(nfreqviewLayout);
sampfreq_input = new QSpinBox();
sampfreq_input->setMinimum(1000);
sampfreq_input->setMaximum(48000);
sampfreq_input->setSingleStep(50);
sampfreq_input->setValue(sampfreq);
QLabel* sampfreq_inputLabel = new QLabel(tr("Sample Freq.:"), parent);
sampfreq_inputLabel->setBuddy(sampfreq_input);
QHBoxLayout* sampfreq_inputLayout = new QHBoxLayout(this);
QWidget* sampfreq_inputWidget = new QWidget(parent);
sampfreq_inputLayout->addWidget(sampfreq_inputLabel);
sampfreq_inputLayout->addWidget(sampfreq_input);
sampfreq_inputWidget->setLayout(sampfreq_inputLayout);
connect(sampfreq_input, SIGNAL(valueChanged(int)), this, SLOT(setSampleFreq(int)));
sampnr_input = new QSpinBox();
sampnr_input->setMinimum(32);
sampnr_input->setMaximum(11048);
sampnr_input->setSingleStep(32);
sampnr_input->setValue(sampnr);
QLabel* sampnr_inputLabel = new QLabel(tr("Sample #:"), parent);
sampnr_inputLabel->setBuddy(sampnr_input);
QHBoxLayout* sampnr_inputLayout = new QHBoxLayout(this);
QWidget* sampnr_inputWidget = new QWidget(parent);
sampnr_inputLayout->addWidget(sampnr_inputLabel);
sampnr_inputLayout->addWidget(sampnr_input);
sampnr_inputWidget->setLayout(sampnr_inputLayout);
connect(sampnr_input, SIGNAL(valueChanged(int)), this, SLOT(setSampleNr(int)));
trigger_input = new QSpinBox();
trigger_input->setMinimum(0);
trigger_input->setMaximum(100);
trigger_input->setSingleStep(10);
trigger_input->setValue((int)(getTrigger()*100.0+0.5));
QLabel* trigger_inputLabel = new QLabel(tr("Trig. (% of max):"), parent);
trigger_inputLabel->setBuddy(trigger_input);
QHBoxLayout* trigger_inputLayout = new QHBoxLayout(this);
QWidget* trigger_inputWidget = new QWidget(parent);
trigger_inputLayout->addWidget(trigger_inputLabel);
trigger_inputLayout->addWidget(trigger_input);
trigger_inputWidget->setLayout(trigger_inputLayout);
connect(trigger_input, SIGNAL(valueChanged(int)), this, SLOT(setTriggerPercent(int)));
QVBoxLayout* infoLayout = new QVBoxLayout(this);
QWidget* infoWidget = new QWidget(parent);
infoLayout->addWidget(freqviewWidget);
infoLayout->addWidget(nfreqviewWidget);
infoLayout->addWidget(sampfreq_inputWidget);
infoLayout->addWidget(sampnr_inputWidget);
infoLayout->addWidget(trigger_inputWidget);
infoWidget->setLayout(infoLayout);
QHBoxLayout* guiupperLayout = new QHBoxLayout(this);
QWidget* guiupperWidget = new QWidget(parent);
guiupperLayout->addWidget(oszi);
guiupperLayout->addWidget(infoWidget);
guiupperWidget->setLayout(guiupperLayout);
QVBoxLayout* mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(guiupperWidget);
mainLayout->addWidget(logview);
// 'this' is the main widget
this->setLayout(mainLayout);
// Start the audio processing
audio->start();
}
static int
GPIO_init(GPIO *self, PyObject *args, PyObject *kwds)
{
int fd = -1;
int gpio = -1;
PyObject * direction = NULL;
PyObject * trigger = NULL;
PyObject * tmp = NULL;
static char *kwlist[] = { "gpio", "direction", "trigger", NULL };
if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|OO:__init__",
kwlist, &gpio, &direction, &trigger ) )
return -1;
if (gpio < 0)
return -1;
self->gpio = gpio;
GPIO_VALUE( gpio, self->v_path );
if ( ( fd = open( self->v_path, O_RDWR, 0 ) ) == -1 ) {
// try to get gpio exported:
if ( exportGpio( gpio ) == 0 ) {
// check if export was (really) successful
if ( ( fd = open( self->v_path, O_RDWR ) ) == -1) {
// export failed
PyErr_SetFromErrno( PyExc_IOError );
return -1;
}
} else {
PyErr_SetString( PyExc_StandardError,
"Export failed." );
return -1;
}
}
GPIO_EDGE(gpio, self->e_path);
GPIO_DIREC(gpio, self->d_path);
self->fd_val = fd;
if ( ( self->fd_dir = open( self->d_path, O_RDWR ) ) == -1 ) {
return -1;
}
if ( ( self->fd_edge = open( self->e_path, O_RDWR ) ) == -1 ) {
return -1;
}
if (direction) {
setDirection( self, direction );
tmp = self->direction;
Py_INCREF(direction);
self->direction = direction;
Py_XDECREF(tmp);
} else {
// no direction requested, use current
Py_XDECREF(self->direction);
self->direction = getDirection( self );
Py_INCREF(self->direction);
}
if (trigger) {
setTrigger( self, trigger );
tmp = self->trigger;
Py_INCREF(trigger);
self->trigger = trigger;
Py_XDECREF(tmp);
} else {
// no trigger requested, use current
Py_XDECREF(self->trigger);
self->trigger = getTrigger( self );
Py_INCREF(self->trigger);
}
return 0;
}
void TextEditorWindow::removeTrigger()
{
if (getTrigger())
((EditorComponent*)getContentComponent())->removeTrigger();
}
bool TextEditorWindow::hasTrigger()
{
return (getTrigger()!=NULL);
}
TriggerGroup* TriggerGroup::delayTriggerState(const std::string& triggerName, Time::TimeUnit delay)
{
m_delayedTriggers.push_back(std::make_unique<TriggerDelay>(getTrigger(triggerName), delay));
return this;
}
// Called within Model::simulate call, below.
void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
Head* head = _owningAvatar->getHead();
if (_owningAvatar->isMyAvatar()) {
MyAvatar* myAvatar = static_cast<MyAvatar*>(_owningAvatar);
const FBXGeometry& geometry = _geometry->getFBXGeometry();
Rig::HeadParameters headParams;
headParams.enableLean = qApp->getAvatarUpdater()->isHMDMode();
headParams.leanSideways = head->getFinalLeanSideways();
headParams.leanForward = head->getFinalLeanForward();
headParams.torsoTwist = head->getTorsoTwist();
if (qApp->getAvatarUpdater()->isHMDMode()) {
headParams.isInHMD = true;
// get HMD position from sensor space into world space, and back into rig space
glm::mat4 worldHMDMat = myAvatar->getSensorToWorldMatrix() * myAvatar->getHMDSensorMatrix();
glm::mat4 rigToWorld = createMatFromQuatAndPos(getRotation(), getTranslation());
glm::mat4 worldToRig = glm::inverse(rigToWorld);
glm::mat4 rigHMDMat = worldToRig * worldHMDMat;
headParams.rigHeadPosition = extractTranslation(rigHMDMat);
headParams.rigHeadOrientation = extractRotation(rigHMDMat);
headParams.worldHeadOrientation = extractRotation(worldHMDMat);
} else {
headParams.isInHMD = false;
// We don't have a valid localHeadPosition.
headParams.rigHeadOrientation = Quaternions::Y_180 * head->getFinalOrientationInLocalFrame();
headParams.worldHeadOrientation = head->getFinalOrientationInWorldFrame();
}
headParams.leanJointIndex = geometry.leanJointIndex;
headParams.neckJointIndex = geometry.neckJointIndex;
headParams.isTalking = head->getTimeWithoutTalking() <= 1.5f;
_rig->updateFromHeadParameters(headParams, deltaTime);
Rig::HandParameters handParams;
auto leftPalm = myAvatar->getHand()->getCopyOfPalmData(HandData::LeftHand);
if (leftPalm.isValid() && leftPalm.isActive()) {
handParams.isLeftEnabled = true;
handParams.leftPosition = Quaternions::Y_180 * leftPalm.getRawPosition();
handParams.leftOrientation = Quaternions::Y_180 * leftPalm.getRawRotation();
handParams.leftTrigger = leftPalm.getTrigger();
} else {
handParams.isLeftEnabled = false;
}
auto rightPalm = myAvatar->getHand()->getCopyOfPalmData(HandData::RightHand);
if (rightPalm.isValid() && rightPalm.isActive()) {
handParams.isRightEnabled = true;
handParams.rightPosition = Quaternions::Y_180 * rightPalm.getRawPosition();
handParams.rightOrientation = Quaternions::Y_180 * rightPalm.getRawRotation();
handParams.rightTrigger = rightPalm.getTrigger();
} else {
handParams.isRightEnabled = false;
}
_rig->updateFromHandParameters(handParams, deltaTime);
_rig->computeMotionAnimationState(deltaTime, _owningAvatar->getPosition(), _owningAvatar->getVelocity(), _owningAvatar->getOrientation());
// evaluate AnimGraph animation and update jointStates.
Model::updateRig(deltaTime, parentTransform);
Rig::EyeParameters eyeParams;
eyeParams.worldHeadOrientation = headParams.worldHeadOrientation;
eyeParams.eyeLookAt = head->getLookAtPosition();
eyeParams.eyeSaccade = head->getSaccade();
eyeParams.modelRotation = getRotation();
eyeParams.modelTranslation = getTranslation();
eyeParams.leftEyeJointIndex = geometry.leftEyeJointIndex;
eyeParams.rightEyeJointIndex = geometry.rightEyeJointIndex;
_rig->updateFromEyeParameters(eyeParams);
} else {
Model::updateRig(deltaTime, parentTransform);
// This is a little more work than we really want.
//
// Other avatars joint, including their eyes, should already be set just like any other joints
// from the wire data. But when looking at me, we want the eyes to use the corrected lookAt.
//
// Thus this should really only be ... else if (_owningAvatar->getHead()->isLookingAtMe()) {...
// However, in the !isLookingAtMe case, the eyes aren't rotating the way they should right now.
// We will revisit that as priorities allow, and particularly after the new rig/animation/joints.
const FBXGeometry& geometry = _geometry->getFBXGeometry();
// If the head is not positioned, updateEyeJoints won't get the math right
glm::quat headOrientation;
_rig->getJointRotation(geometry.headJointIndex, headOrientation);
glm::vec3 eulers = safeEulerAngles(headOrientation);
head->setBasePitch(glm::degrees(-eulers.x));
head->setBaseYaw(glm::degrees(eulers.y));
head->setBaseRoll(glm::degrees(-eulers.z));
Rig::EyeParameters eyeParams;
eyeParams.worldHeadOrientation = head->getFinalOrientationInWorldFrame();
eyeParams.eyeLookAt = head->getCorrectedLookAtPosition();
eyeParams.eyeSaccade = glm::vec3();
eyeParams.modelRotation = getRotation();
eyeParams.modelTranslation = getTranslation();
eyeParams.leftEyeJointIndex = geometry.leftEyeJointIndex;
eyeParams.rightEyeJointIndex = geometry.rightEyeJointIndex;
_rig->updateFromEyeParameters(eyeParams);
}
}
