コード例 #1
0
void Interpreter::execute(QString command)
{
    if (m_running==true)
        queueCommand(STOP);
    if (m_localProgramRunning)
        queueCommand(STOP_LOCAL);

    command.remove(QRegExp("^\\s+")); // remove leading whitespace
    if (command!="")
        emit consoleCommand(command);
}
コード例 #2
0
ファイル: interpreter.cpp プロジェクト: BallisticPain/pixy
void Interpreter::runOrStopProgram()
{
    unwait(); // unhang ourselves if we're waiting
    if (m_localProgramRunning)
        m_localProgramRunning = false;
    else if (m_running==false)
        queueCommand(RUN);
    else if (m_running==true)
        queueCommand(STOP);
    // no case to run local program because this is sort of an undocumented feature for now
}
コード例 #3
0
void CanvasTexture::del()
{
    if (!invalidated() && m_textureId) {
        if (m_quickItem) {
            m_context->quickItemToTextureMap().remove(m_quickItem);
            m_quickItem = 0;
            queueCommand(CanvasGlCommandQueue::internalClearQuickItemAsTexture, m_textureId);
        } else {
            queueCommand(CanvasGlCommandQueue::glDeleteTextures, m_textureId);
        }
    }
    m_textureId = 0;
}
コード例 #4
0
ファイル: framebuffer3d.cpp プロジェクト: 2gis/2gisqt5android
void CanvasFrameBuffer::del()
{
    if (m_framebufferId) {
        queueCommand(CanvasGlCommandQueue::glDeleteFramebuffers, m_framebufferId);
        m_framebufferId = 0;
    }
}
コード例 #5
0
QT_BEGIN_NAMESPACE
QT_CANVAS3D_BEGIN_NAMESPACE

/*!
 * \qmltype Canvas3DTexture
 * \since QtCanvas3D 1.0
 * \inqmlmodule QtCanvas3D
 * \inherits Canvas3DAbstractObject
 * \brief Contains an OpenGL texture.
 *
 * An uncreatable QML type that contains an OpenGL texture. You can get it by calling
 * the \l{Context3D::createTexture()}{Context3D.createTexture()} method.
 */

CanvasTexture::CanvasTexture(CanvasGlCommandQueue *queue, CanvasContext *context,
                             QQuickItem *quickItem) :
    CanvasAbstractObject(queue, context),
    m_textureId(queue->createResourceId()),
    m_isAlive(true),
    m_context(context),
    m_quickItem(quickItem)
{
    if (m_quickItem)
        connect(m_quickItem, &QObject::destroyed, this, &CanvasTexture::handleItemDestroyed);
    else
        queueCommand(CanvasGlCommandQueue::glGenTextures, m_textureId);
}
コード例 #6
0
    //--------------------------------------------------------------
    void Controller::exitBootstrap() {
        std::cout<<"ofxARDrone::Controller::exitBootstrap";
        
        Command configCommand;
        configCommand.setName("CONFIG");
        configCommand.addString("general:navdata_demo");
        configCommand.addString("TRUE");
        queueCommand(configCommand);

//        queueCommand("AT*CONFIG="+toString(drone->sequenceNumber++)+",\"general:navdata_demo\",\"TRUE\"");
        
        Command command;
        command.setName("CTRL");
        command.addInt(5);
        queueCommand(command);
    }
コード例 #7
0
    //--------------------------------------------------------------
    void Controller::queueCommand(Command &command) {
        if(drone == NULL) { std::cerr<<"   Drone is NULL"; return; }

        string commandString = command.getString(drone->sequenceNumber);
        
        queueCommand(commandString);
        drone->sequenceNumber++;
    }
コード例 #8
0
ファイル: interpreter.cpp プロジェクト: BallisticPain/pixy
void Interpreter::execute(const QString &command)
{
    QStringList argv = command.split(QRegExp("[\\s(),\\t]"), QString::SkipEmptyParts);
    unwait(); // unhang ourselves if we're waiting for input
    m_mutexProg.lock();
    m_argv = argv;
    m_externalCommand = command; // save command so we can print.  This variable also indicates that we're not a human typing a command
    m_mutexProg.unlock();
    if (m_running==true)
        queueCommand(STOP);
}
コード例 #9
0
GlCommand &CanvasGlCommandQueue::queueCommand(CanvasGlCommandQueue::GlCommandId id, GLfloat p1,
                                              GLfloat p2, GLfloat p3, GLfloat p4)
{
    GlCommand &command = queueCommand(id);
    command.f1 = p1;
    command.f2 = p2;
    command.f3 = p3;
    command.f4 = p4;

    return command;
}
コード例 #10
0
void Interpreter::handleLocalProgram()
{
    int res;

    if (m_program.size()>0 && m_localProgramRunning)
    {
        if (m_pc>=m_program.size())
            m_pc = 0;
        res = m_chirp->execute(m_program[m_pc]);
        if (res<0)
            queueCommand(STOP_LOCAL);
        m_pc++;
    }
}
コード例 #11
0
void Interpreter::command(const QString &command)
{
    QMutexLocker locker(&m_mutexInput);

    if (m_localProgramRunning)
        return;

    QStringList words = command.split(QRegExp("[\\s(),\\t]"), QString::SkipEmptyParts);

    if (m_waiting)
    {
        m_command = command;
        m_command.remove(QRegExp("[(),\\t]"));
        m_key = (Qt::Key)0;
        m_selection = RectA(0, 0, 0, 0);
        m_waitInput.wakeAll();
        goto end;
    }

    if (words.size()==0)
        goto end;

    if (words[0]=="do")
    {
        clearLocalProgram();
        beginLocalProgram();
    }
    else if (words[0]=="done")
    {
        endLocalProgram();
        locker.unlock();
        runOrStopProgram(true);
        locker.relock();
    }
    else if (words[0]=="list")
        listProgram();
    else if (words[0].left(4)=="cont")
    {
        locker.unlock();
        runOrStopProgram(true);
        locker.relock();
    }
    else if (words[0]=="close")
        queueCommand(CLOSE);
    else
        handleCall(words);
end:
    prompt();
}
コード例 #12
0
GlCommand &CanvasGlCommandQueue::queueCommand(CanvasGlCommandQueue::GlCommandId id, GLint p1,
                                              GLint p2, GLint p3, GLint p4, GLint p5, GLint p6,
                                              GLint p7, GLint p8)
{
    GlCommand &command = queueCommand(id);
    command.i1 = p1;
    command.i2 = p2;
    command.i3 = p3;
    command.i4 = p4;
    command.i5 = p5;
    command.i6 = p6;
    command.i7 = p7;
    command.i8 = p8;

    return command;
}
コード例 #13
0
 //--------------------------------------------------------------
 void Controller::emergency(int on) {
     std::cout<<"ofxARDrone::Controller::emergency -  + toString(on)";
     
     Command command;
     command.setName("REF");
     
     msa::BitField32 bitField;
     bitField.clearAll();
     bitField.setBit(18);
     bitField.setBit(20);
     bitField.setBit(22);
     bitField.setBit(24);
     bitField.setBit(28);
     bitField.setBit(8, on);
     command.addInt(bitField);
     
     queueCommand(command);
 }
コード例 #14
0
ファイル: framebuffer3d.cpp プロジェクト: 2gis/2gisqt5android
QT_BEGIN_NAMESPACE
QT_CANVAS3D_BEGIN_NAMESPACE

/*!
 * \qmltype Canvas3DFrameBuffer
 * \since QtCanvas3D 1.0
 * \inqmlmodule QtCanvas3D
 * \inherits Canvas3DAbstractObject
 * \brief Contains an OpenGL framebuffer.
 *
 * An uncreatable QML type that contains an OpenGL framebuffer object. You can get it by calling the
 * \l{Context3D::createFramebuffer()}{Context3D.createFramebuffer()} method.
 */

CanvasFrameBuffer::CanvasFrameBuffer(CanvasGlCommandQueue *queue, QObject *parent) :
    CanvasAbstractObject(queue, parent),
    m_framebufferId(queue->createResourceId()),
    m_texture(0)
{
    queueCommand(CanvasGlCommandQueue::glGenFramebuffers, m_framebufferId);
}
コード例 #15
0
ファイル: CommandDispatcher.cpp プロジェクト: derkling/CBox
exitCode CommandDispatcher::dispatch(Command * command, bool clean)
throw (exceptions::OutOfMemoryException) {

    LOG4CPP_DEBUG(log, "CommandDispatcher::dispatch(Command * command)");

    // If disabled...
    if ( d_suspended ) {
        // Queuing command for handler notify
        LOG4CPP_INFO(log, "Disaptcher suspended; queuing new Command for delayed dispatching");
        queueCommand(command);
        return DIS_SUSPENDED;
    }

    // Dispatching command immediatly
    d_handler->notify(command);
    if ( clean ) {
    	delete command;
    }

    return OK;

}
コード例 #16
0
//==============================================================================
ObjectHandle CompoundCommand::execute(const ObjectHandle& arguments) const
{
	auto cmdSysProvider = getCommandSystemProvider();
	assert(cmdSysProvider != nullptr);
	MacroEditObject* ccArgs = arguments.getBase<MacroEditObject>();
	assert(ccArgs);

	std::vector<CommandInstance*> subInstances;
	subInstances.reserve(subCommands_.size());
	CommandInstancePtr instance;

	for (SubCommandCollection::size_type i = 0; i < subCommands_.size(); ++i)
	{
		ccArgs->resolveDependecy(i, subInstances);
		instance = cmdSysProvider->queueCommand(subCommands_[i].first.c_str(), ccArgs->getCommandArgument(i));
		assert(instance != nullptr);
		cmdSysProvider->waitForInstance(instance);
		subInstances.push_back(instance.get());
	}

	return instance->getReturnValue();
}
コード例 #17
0
void Interpreter::runOrStopProgram(bool local)
{
    unwait(); // unhang ourselves if we're waiting
    if (local)
    {
        if (m_running)
            queueCommand(STOP);
        else if (m_localProgramRunning)
            queueCommand(STOP_LOCAL);
        else
            queueCommand(RUN_LOCAL);
    }
    else
    {
        if (m_localProgramRunning)
            queueCommand(STOP_LOCAL);
        else if (m_running==false)
            queueCommand(RUN);
        else if (m_running==true)
            queueCommand(STOP);
        // note m_running has 3 states...
    }
}
コード例 #18
0
    //--------------------------------------------------------------
    void Controller::update() {
        if(drone == NULL) { std::cerr<<"   Drone is NULL"; return; }
        
        State &state = drone->state;
        
        if(state.isCalibratingHorizontal()) {
            if(state.isFlying()) {
                std::cerr<<"ofxARDrone::Controller::update - shouldn't calibrate horizontal while flying";
                state.setCalibratingHorizontal(false, 0);
            } else {
                Command command;
                command.setName("FTRIM");
                queueCommand(command);
            }
        }
        
        
        if(state.isCalibratingMagnetometer()) {
            if(!state.isFlying()) {
                std::cerr<<"ofxARDrone::Controller::update - should only calibrate magnetometer while flying";
                state.setCalibratingMagnetometer(false, 0);
            } else {
                Command command;
                command.setName("CALIB");
                queueCommand(command);
            }
        }
        
        if(state.isTakingOff() || state.isLanding()) {
            Command command;
            command.setName("REF");
            
            msa::BitField32 bitField;
            bitField.clearAll();
            bitField.setBit(18);
            bitField.setBit(20);
            bitField.setBit(22);
            bitField.setBit(24);
            bitField.setBit(28);
            bitField.setBit(9, state.isTakingOff()); // keep sending until navdata says it's taken off, or landed
            command.addInt(bitField);
            
            queueCommand(command);
        }
        
        rollAmount = cinder::math<float>::clamp(rollAmount, -1, 1);
        pitchAmount = cinder::math<float>::clamp(pitchAmount, -1, 1);
        liftSpeed = cinder::math<float>::clamp(liftSpeed, -1, 1);
        spinSpeed = cinder::math<float>::clamp(spinSpeed, -1, 1);
        
        if(state.isFlying()) {
            Command command;
            command.setName("PCMD");
            command.addInt(1);
            command.addFloat(rollAmount);
            command.addFloat(pitchAmount);
            command.addFloat(liftSpeed);
            command.addFloat(spinSpeed);
            
            queueCommand(command);
        }
        
        
        if(commandString.empty() && getMillisSinceLastSend() > 50) resetCommunicationWatchdog();

        
        if(commandString.empty() == false) {
//            udpSender.Send(commandString.c_str(), commandString.length());
            commandHistory.push_front(commandString);

//            millisOfLastSend = ofGetElapsedTimeMillis();
            this->commandString = "";
        }
    }
コード例 #19
0
ファイル: interpreter.cpp プロジェクト: BallisticPain/pixy
void Interpreter::getAction(int index)
{
    queueCommand(GET_ACTION, index);
}
コード例 #20
0
    //--------------------------------------------------------------
    void Controller::resetCommunicationWatchdog() {
//        std::cout<<"ofxARDrone::Controller::resetCommunicationWatchdog");
        
        queueCommand("AT*COMWDG");
    }
コード例 #21
0
 //--------------------------------------------------------------
 void Controller::sendAck() {
     std::cout<<"ofxARDrone::Controller::sendAck";
     queueCommand("AT*CTRL=0");
 }
コード例 #22
0
ファイル: interpreter.cpp プロジェクト: BallisticPain/pixy
void Interpreter::saveParams()
{
    queueCommand(SAVE_PARAMS);
}
コード例 #23
0
void Interpreter::updateParam()
{
    queueCommand(UPDATE_PARAM);
}
コード例 #24
0
void CanvasTexture::bind(CanvasContext::glEnums target)
{
    if (m_textureId)
        queueCommand(CanvasGlCommandQueue::glBindTexture, GLint(target), m_textureId);
}
コード例 #25
0
void Interpreter::loadParams()
{
    queueCommand(LOAD_PARAMS);
}
コード例 #26
0
void Interpreter::saveParams(bool reject)
{
    queueCommand(SAVE_PARAMS, reject);
}
コード例 #27
0
ファイル: sfx_manager.cpp プロジェクト: Charence/stk-code
/** Adds a sound effect command with a single floating point parameter to the
 *  queue of the sfx manager. Openal commands can sometimes cause a 5ms delay,
 *  so it is done in a separate thread.
 *  \param command The command to execute.
 *  \param sfx The sound effect to be started.
 *  \param f Floating point parameter for the command.
 */
void SFXManager::queue(SFXCommands command, SFXBase *sfx, float f)
{
    SFXCommand *sfx_command = new SFXCommand(command, sfx, f);
    queueCommand(sfx_command);
}   // queue(float)
コード例 #28
0
ファイル: sfx_manager.cpp プロジェクト: Charence/stk-code
/** Queues a command for the music manager that takes a floating point value
 *  (e.g. setTemporaryVolume).
 *  \param mi The music for which the command is.
 *  \param f The floating point parameter.
 */
void SFXManager::queue(SFXCommands command, MusicInformation *mi, float f)
{
    SFXCommand *sfx_command = new SFXCommand(command, mi, f);
    queueCommand(sfx_command);
}   // queue(MusicInformation)
コード例 #29
0
ファイル: sfx_manager.cpp プロジェクト: Charence/stk-code
/** Adds a sound effect command with a Vec3 parameter to the queue of the sfx
 *  manager. Openal commands can sometimes cause a 5ms delay, so it is done in
 *  a separate thread.
 *  \param command The command to execute.
 *  \param sfx The sound effect to be started.
 *  \param p A Vec3 parameter for the command.
 */
void SFXManager::queue(SFXCommands command, SFXBase *sfx, const Vec3 &p)
{
   SFXCommand *sfx_command = new SFXCommand(command, sfx, p);
   queueCommand(sfx_command);
}   // queue (Vec3)