C++ CommandQueue类代码示例

bool Dispatcher::dispatchCommand( ICommand& command )
{
    LBASSERT( command.isValid( ));

    LBVERB << "dispatch " << command << " on " << lunchbox::className( this )
           << std::endl;

    const uint32_t which = command.getCommand();
#ifndef NDEBUG
    if( which >= _impl->qTable.size( ))
    {
        LBABORT( "ICommand " << command
                 << " higher than number of registered command handlers ("
                 << _impl->qTable.size() << ") for object of type "
                 << lunchbox::className( this ) << std::endl );
        return false;
    }
#endif

    CommandQueue* queue = _impl->qTable[ which ];
    if( queue )
    {
        command.setDispatchFunction( _impl->fTable[ which ] );
        queue->push( command );
        return true;
    }
    // else

    LBCHECK( _impl->fTable[ which ]( command ));
    return true;
}

bool Dispatcher::dispatchCommand( Command& command )
{
    EQVERB << "dispatch " << command << " on " << base::className( this )
           << std::endl;

    const uint32_t which = command->command;
#ifndef NDEBUG
    if( which >= _qTable.size( ))
    {
        EQABORT( "Command " << command
                 << " higher than number of registered command handlers ("
                 << _qTable.size() << ") for object of type "
                 << base::className( this ) << std::endl );
        return false;
    }
#endif

    CommandQueue* queue = _qTable[which];
    if( queue )
    {
        command.setDispatchFunction( _fTable[which] );
        queue->push( command );
        return true;
    }
    // else

    EQCHECK( _fTable[which]( command ));
    return true;
}

void Player::HandleEvent(const sf::Event& event, CommandQueue& commands)
{

	if ( m_useJoystick )
	{
		Command_t c;
		c.category = Category::PlayerAircraft;
		if ( event.type == sf::Event::JoystickButtonPressed )
		{
			if ( event.joystickButton.button == 2)
			//if ( sf::Joystick::isButtonPressed( 0, 2 ) )
			{
				// yes: shoot!
				c.action = DerivedAction<Creature>( []( Creature& a, sf::Time ){ a.LaunchMissile(); } );
				commands.Push( c );
			}
		}
	}
	else
	{
		if ( event.type == sf::Event::KeyPressed )
		{
			// Check if pressed key appears in key binding, trigger command if so
			auto found = m_keyBinding.find( event.key.code );
			if ( found != m_keyBinding.end() && !IsRealtimeAction( found->second ) )
				commands.Push( m_actionBinding[found->second] );
		}
	}
	
}

//protected
ICommand* AbstractManager::dequeueCommand()
{
    ICommand* command=0;
    if(mLock.tryLockForWrite(mReadMaxWait))
    {
        for(int severity=ICommand::HIGH;
            severity <= ICommand::LOW;
            severity++)
        {
            CommandQueue* queue = mHashCommandQueues.value(severity,0);
            if(queue)
            {
                if(!queue->isEmpty())
                {
                    command = queue->dequeue();
                    if(command)
                    {
                        break;
                    }
                }
            }
        }
        mLock.unlock();
    }
    return command;
}

Heap * Heap::Alloc(ID3D12Device * Device, int Type) {
    Heap * heap = 0;
    D3D12Render * render = D3D12Render::GetRender();
    CommandQueue * Queue = render->GetQueue(D3D12_COMMAND_LIST_TYPE_DIRECT);
    if (Free.Size()) {
        heap = Free.PopBack();
    }
    else {
        bool Found = 0;
        for (auto Iter = Retired.Begin(); Iter != Retired.End(); Iter++) {
            heap = *Iter;
            UINT64 FenceValue = heap->FenceValue;
            if (Queue->FenceComplete(FenceValue)) {
                Retired.Remove(Iter);
                Found = 1;
                break;
            }
        }
        if (!Found) {
            heap = 0;
        }
    }
    if (heap) {
        return heap;
    }
    else {
        // new context
        heap = new Heap();
        heap->Init(Device, MAX_CONSTANT_BUFFER_HEAP, Type);
    }
    return heap;
}

void Aircraft::checkProjectileLaunch(sf::Time dt, CommandQueue& commands)
{
	// Enemies try to fire all the time
	if (!isAllied())
		fire();

	// Check for automatic gunfire, allow only in intervals
	if (mIsFiring && mFireCountdown <= sf::Time::Zero)
	{
		// Interval expired: We can fire a new bullet
		commands.push(mFireCommand);
		mFireCountdown += Table[mType].fireInterval / (mFireRateLevel + 1.f);
		mIsFiring = false;
	}
	else if (mFireCountdown > sf::Time::Zero)
	{
		// Interval not expired: Decrease it further
		mFireCountdown -= dt;
		mIsFiring = false;
	}

	// Check for missile launch
	if (mIsLaunchingMissile)
	{
		commands.push(mMissileCommand);
		mIsLaunchingMissile = false;
	}
}

MessagePump* Pipe::getMessagePump()
{
    LB_TS_THREAD( _pipeThread );
    if( !_impl->thread )
        return 0;

    CommandQueue* queue = _impl->thread->getWorkerQueue();
    return queue->getMessagePump();
}

void Pipe::_exitCommandQueue()
{
    // Non-threaded pipes have no pipe thread message pump
    if( !_impl->thread )
        return;

    CommandQueue* queue = _impl->thread->getWorkerQueue();
    LBASSERT( queue );

    MessagePump* pump = queue->getMessagePump();
    queue->setMessagePump( 0 );
    delete pump;
}

bool Event::removeWaitEvent(Event *event)
{
    bool empty;

    pthread_mutex_lock(&p_state_mutex);
    p_wait_events.remove(event);
    empty = p_wait_events.empty();
    pthread_mutex_unlock(&p_state_mutex);

    CommandQueue *q = (CommandQueue *) event->parent();
    if (q != NULL) q->releaseEvent(event);
    return empty;
}

int main(int argc, char ** argv) {
    // Load image
    SIPL::Image<float> * image = new SIPL::Image<float>("images/sunset.jpg");

    // Create OpenCL context
    Context context = createCLContextFromArguments(argc, argv);

    // Compile OpenCL code
    Program program = buildProgramFromSource(context, "gaussian_blur.cl");

    // Select device and create a command queue for it
    VECTOR_CLASS<Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
    CommandQueue queue = CommandQueue(context, devices[0]);

    // Create an OpenCL Image / texture and transfer data to the device
    Image2D clImage = Image2D(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, ImageFormat(CL_R, CL_FLOAT), image->getWidth(), image->getHeight(), 0, (void*)image->getData());

    // Create a buffer for the result
    Buffer clResult = Buffer(context, CL_MEM_WRITE_ONLY, sizeof(float)*image->getWidth()*image->getHeight());

    // Create Gaussian mask
    int maskSize;
    float * mask = createBlurMask(10.0f, &maskSize);

    // Create buffer for mask and transfer it to the device
    Buffer clMask = Buffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float)*(maskSize*2+1)*(maskSize*2+1), mask);

    // Run Gaussian kernel
    Kernel gaussianBlur = Kernel(program, "gaussian_blur");
    gaussianBlur.setArg(0, clImage);
    gaussianBlur.setArg(1, clMask);
    gaussianBlur.setArg(2, clResult);
    gaussianBlur.setArg(3, maskSize);

    queue.enqueueNDRangeKernel(
        gaussianBlur,
        NullRange,
        NDRange(image->getWidth(), image->getHeight()),
        NullRange
    );

    // Transfer image back to host
    float* data = new float[image->getWidth()*image->getHeight()];
    queue.enqueueReadBuffer(clResult, CL_TRUE, 0, sizeof(float)*image->getWidth()*image->getHeight(), data);
    image->setData(data);

    // Save image to disk
    image->save("images/result.jpg", "jpeg");
    image->display();
}

void Aircraft::checkPickupDrop(CommandQueue& commands)
{
	if (!isAllied() && randomInt(3) == 0 && !mSpawnedPickup)
		commands.push(mDropPickupCommand);

	mSpawnedPickup = true;
}

void Player::updateInput(CommandQueue &command_queue)
{
	if (keyboard_works == true)
	for (auto &itr : key_to_action)
	{
		//If the key is pressed add to the set. If not then delete from the set.
		//If it's a new key then refresh the last_key_pressed and current_action
		if (sf::Keyboard::isKeyPressed(itr.first)) 
		{
			auto key = keys_pressed.find(itr.first);
			if (key == keys_pressed.end())
			{
				current_action = key_to_action[itr.first];
				last_key_pressed = itr.first;
			}
			keys_pressed.insert(itr.first);
		}
		else
		{
			auto key = keys_pressed.find(itr.first);
			if (key != keys_pressed.end()) keys_pressed.erase(itr.first);
		}
	}


	if(last_key_pressed != 0 && keyboard_works == true)
		command_queue.push(action_to_command[current_action]);
	//command_queue.push(action_to_command[key_to_action[last_key_pressed]]);
}

void Player::handleEvent(const sf::Event& event, CommandQueue& commands)
{
    // event souris
    if (event.type == sf::Event::KeyPressed)
    {
         auto found = m_keyBinding.find(event.key.code);
            if (found != m_keyBinding.end() && !isRealtimeAction(found->second))
                commands.push(m_actionBinding[found->second]);
    }
    else if(event.type == sf::Event::MouseButtonPressed)
    {
        auto found = m_mouseBinding.find(event.mouseButton.button);
            if (found != m_mouseBinding.end() && !isRealtimeAction(found->second))
                commands.push(m_actionBinding[found->second]);
    }
}

void Tile::updateCurrent(sf::Time dt, CommandQueue& commands)
{
	// Entity has been destroyed: Possibly drop pickup, mark for removal
	if (isDestroyed())
	{
		checkPickupDrop(commands);
		mExplosion.update(dt);
		// Play explosion sound only once
		if (!mExplosionBegan)
		{
			// Play sound effect
			SoundEffect::ID soundEffect = (randomInt(2) == 0) ? SoundEffect::Explosion1 : SoundEffect::Explosion2;
			playLocalSound(commands, soundEffect);

			// Emit network game action for explosions
			if (isBlock())
			{
				sf::Vector2f position = getWorldPosition();

				Command command;
				command.category = Category::Network;
				command.action = derivedAction<NetworkNode>([position] (NetworkNode& node, sf::Time)
															{
																node.notifyGameAction(GameActions::EnemyExplode, position);
															});

				commands.push(command);
				mExplosionBegan = true;
			}
		}
		return;
	}

	Entity::updateCurrent(dt, commands);
}

void Player::handleRealtimeInput(CommandQueue& commands) {
	// Checks every key for a press
	for (auto pair : mKeyBinding) {
		// if something is pressed make sure to trigger command
		if (sf::Keyboard::isKeyPressed(pair.first) && isRealtimeAction(pair.second))
			commands.push(mActionBinding[pair.second]);
	}
}