C++ PushCommand函数代码示例

void TimepixProducer::OnStopRun()
{
	pixelmanCtrl->m_commHistRunCtrl.AddString(_T("End Of Run."));

	if ( GetRunStatusFlag() == TimepixProducer::RUN_STOPPED )
	{
		// give a warning to eudaq and do nothing
	    EUDAQ_WARN("StopRun requested when run not active");
		SetStatus(eudaq::Status::LVL_WARN, "StopRun requested when run not active");
	}
	else
	{
		// send STOP_RUN command to the daq thread
		PushCommand( STOP_RUN );

		// wait for the daq thread to lower the run active flag
		while ( GetRunStatusFlag() == RUN_ACTIVE )
		{
			Sleep(1);
		}
		
		//EUDAQ_DEBUG("Sending EORE");
		Sleep(1000);
		SendEvent(eudaq::RawDataEvent::EORE(_T("Timepix"),GetRunNumber(), GetEventNumber()));
		//std::cout << "Stop Run" << std::endl;
		//MessageBox(NULL, "End Of Run", "Message from Runcontrol",NULL);
		EUDAQ_INFO("Run Stopped");
		SetStatus(eudaq::Status::LVL_OK, "Run Stopped");

	}
}

    void ArAIProperty::CommandMoveTo(ArObjID targetID, float range /*= 0.0f*/)
    {
        if (!mAIList.empty())
        {
            if (mAIList.front()->GetType() == ENUM_AI_TYPE_MOVETOTARGET)
                return;
        }

        if (ArGameApp::Get()->GetEntityManager()->IsHero(GetEntity<ArGameEntity>()->GetID()))
        {
            double time = Driver->GetElapsedSecond();
            if (time - mLastMoveTime < DEF_AI_MOVE_REQUEST_MIN_TIME)
            {
                return;
            }
            mLastMoveTime = time;
        }
        if (GetEntity<ArGameEntity>()->IsDead())
        {
            return;
        }
        ClearAIList();

        auto pCmd = DI_NEW ArAIMoveToTargetCommand(mEntity, targetID, range);
        PushCommand(pCmd);
    }

void System_AskForPermission(SystemPermission permission) {
	switch (permission) {
	case SYSTEM_PERMISSION_STORAGE:
		PushCommand("ask_permission", "storage");
		break;
	}
}

void UFlareSpacecraftNavigationSystem::PushCommandLinearBrake(const FVector& VelocityTarget)
{
	FFlareShipCommandData Command;
	Command.Type = EFlareCommandDataType::CDT_BrakeLocation;
	Command.VelocityTarget = VelocityTarget;
	PushCommand(Command);
}

void TimepixProducer::OnReset()
{
	pixelmanCtrl->m_commHistRunCtrl.AddString(_T("Reset."));
	PushCommand( RESET );
	
	//std::cout << "Reset" << std::endl;
    //SetStatus(eudaq::Status::LVL_OK);
}

 void Controller::Resize(uint32_t width, uint32_t height) {
     if (mStatus == State::kRunning || mStatus == State::kPaused) {
         Command cmd(Cmd::kResize);
         cmd.arg1 = width;
         cmd.arg2 = height;
         PushCommand(cmd);
     }
 }

 void Controller::Resume() {
     if (mStatus == State::kPaused) {
         std::unique_lock<std::mutex> locker(mConditionMutex);
         mStatus = State::kRunning;
         PushCommand(Cmd::kResume);
         mCondition.notify_all();
     }
 }

internal rc_set_camera_matrix*
PushSetCameraMatrix(render_buffer* RenderBuffer, mat4 Matrix)
{
    rc_set_camera_matrix Command = {0};
    Command.Matrix               = Matrix;

    return (rc_set_camera_matrix*)PushCommand(RenderBuffer, RenderCommand_SetCameraMatrix, &Command);
}

internal rc_load_texture*
PushLoadTexture(render_buffer* RenderBuffer, texture_slot* TextureSlot, bool32 Interpolate, char* Filename)
{
    rc_load_texture Command = {0};
    Command.TextureSlot     = TextureSlot;
    Command.Filename        = Filename;

    return (rc_load_texture*)PushCommand(RenderBuffer, RenderCommand_LoadTexture, &Command);
}

void TimepixProducer::OnTerminate()
{	
	DEVID devId = pixelmanCtrl->mpxDevId[pixelmanCtrl->mpxCurrSel].deviceId;
	pixelmanCtrl->mpxCtrlAbortOperation(devId);
	pixelmanCtrl->m_commHistRunCtrl.AddString(_T("Terminated (I'll be back)"));
	//std::cout << "Terminate (press enter)" << std::endl;
    SetDone( true );
	PushCommand( TERMINATE );
	
}

internal rc_draw_rect_multitextured*
PushDrawRectMultitextured(render_buffer* RenderBuffer, vec2 Mid, vec2 Size)
{
    rc_draw_rect_multitextured Command = {0};
    Command.Mid                        = Mid;
    Command.Size                       = Size;
    Command.Color                      = Vec4i(1, 1, 1, 1);

    return (rc_draw_rect_multitextured*)PushCommand(RenderBuffer, RenderCommand_DrawRectMultitextured, &Command);
}

internal rc_draw_rect_outline*
PushDrawRectOutline(render_buffer* RenderBuffer, vec2 Mid, vec2 Size, vec4 Color)
{
    rc_draw_rect_outline Command = {0};
    Command.Mid                  = Mid;
    Command.Size                 = Size;
    Command.Color                = Color;

    return (rc_draw_rect_outline*)PushCommand(RenderBuffer, RenderCommand_DrawRectOutline, &Command);
}

internal rc_draw_line*
PushDrawLine(render_buffer* RenderBuffer, vec2 Start, vec2 End, vec4 Color)
{
    rc_draw_line Command = {0};
    Command.Start        = Start;
    Command.End          = End;
    Command.Color        = Color;

    return (rc_draw_line*)PushCommand(RenderBuffer, RenderCommand_DrawLine, &Command);
}

internal rc_load_font*
PushLoadFont(render_buffer* RenderBuffer, font_slot* FontSlot, char* Filename, float Height)
{
    rc_load_font Command = {0};
    Command.FontSlot     = FontSlot;
    Command.Filename     = Filename;
    Command.Height       = Height;
    Command.OversampleX  = 2;
    Command.OversampleY  = 2;

    return (rc_load_font*)PushCommand(RenderBuffer, RenderCommand_LoadFont, &Command);
}

    void Controller::Stop() {
        if (mStatus == State::kRunning || mStatus == State::kPaused) {
            if (mStatus == State::kPaused) {
                Resume();
            }

            PushCommand(Cmd::kStop);
            if (mWorker.joinable()) {
                mWorker.join();
            }
        }
    }