void Direct3DBlitter::lockTexture(SetBuffer setInputBuffer) {
RECT const rect = { 0, 0, inBuffer().width, inBuffer().height };
D3DLOCKED_RECT lockedrect;
lockedrect.pBits = 0;
if (stexture)
stexture->LockRect(0, &lockedrect, &rect, D3DLOCK_NOSYSLOCK);
setInputBuffer(lockedrect.pBits, PixelBuffer::RGB32, lockedrect.Pitch >> 2);
}
void Direct3DBlitter::lockTexture() {
const RECT rect = { left: 0, top: 0, right: inBuffer().width, bottom: inBuffer().height };
D3DLOCKED_RECT lockedrect;
lockedrect.pBits = NULL;
if (stexture)
stexture->LockRect(0, &lockedrect, &rect, D3DLOCK_NOSYSLOCK);
setPixelBuffer(lockedrect.pBits, PixelBuffer::RGB32, lockedrect.Pitch >> 2);
}
unsigned Direct3DBlitter::textureSizeFromInBufferSize() const {
unsigned textRes = std::max(inBuffer().width, inBuffer().height);
--textRes;
textRes |= textRes >> 1;
textRes |= textRes >> 2;
textRes |= textRes >> 4;
textRes |= textRes >> 8;
++textRes;
return textRes;
}
virtual void consumeBuffer(SetBuffer setInputBuffer) {
QImage &frontBuf = inBuffer().data == image0_->bits() ? *image1_ : *image0_;
if (image0_->size() == image1_->size()) {
// flip
setInputBuffer(frontBuf.bits(), PixelBuffer::RGB32,
frontBuf.bytesPerLine() >> 2);
} else {
static void
resample_linear(void* _inBuffer, void* _outBuffer, uint32 channelCount,
double inFrameRate, double outFrameRate, int32 frames)
{
typedef double sample_t;
Buffer inBuffer(_inBuffer);
Buffer outFrameBuf(_outBuffer);
for (sample_t outFrame = 0; outFrame < frames; outFrame++) {
// time of the out sample
sample_t outTime = outFrame / outFrameRate;
// first in frame
int64 inFrame = int64(outTime * inFrameRate);
// time of the first and the second in frame
sample_t inTime1 = (sample_t)inFrame / inFrameRate;
sample_t inTime2 = (sample_t)(inFrame + 1) / inFrameRate;
// differences between the out frame time and the in frame times
sample_t timeDiff1 = outTime - inTime1;
sample_t timeDiff2 = inTime2 - outTime;
sample_t timeDiff = timeDiff1 + timeDiff2;
// pointer to the first and second in frame
Buffer inFrameBuf1 = inBuffer + inFrame * channelCount;
Buffer inFrameBuf2 = inFrameBuf1 + channelCount;
for (uint32 c = 0; c < channelCount;
c++, inFrameBuf1++, inFrameBuf2++, outFrameBuf++) {
// sum weighted according to the distance to the respective other
// in frame
outFrameBuf.WriteSample((timeDiff2 * inFrameBuf1.ReadSample()
+ timeDiff1 * inFrameBuf2.ReadSample()) / timeDiff);
}
}
}
void SocketProvider::GetExtensionFunctionPtr(const SocketPtr &socket, GUID *guid, LPVOID pfn)
{
BufferPtr inBuffer(sizeof(GUID), NoRebindTag());
BufferPtr outBuffer(sizeof(void *), NoRebindTag());
RtlMoveMemory(inBuffer->Pointer(), guid, sizeof(GUID));
socket->IOControl(SIO_GET_EXTENSION_FUNCTION_POINTER, inBuffer, outBuffer);
RtlMoveMemory(pfn, outBuffer->Pointer(), sizeof(void *));
}
void Direct3DBlitter::setVertexBuffer() {
if (!vertexBuffer)
return;
Vertex *vertices = 0;
if (!FAILED(vertexBuffer->Lock(0, 0, reinterpret_cast<VOID **>(&vertices), 0))) {
unsigned const textRes = textureSizeFromInBufferSize();
unsigned const xoffset = backBufferWidth > static_cast<unsigned>(width())
? (backBufferWidth - width()) >> 1
: 0;
unsigned const yoffset = backBufferHeight > static_cast<unsigned>(height())
? (backBufferHeight - height()) >> 1
: 0;
vertices[0].x = xoffset - 0.5f;
vertices[0].y = yoffset + height() - 0.5f;
vertices[0].z = 0.0f;
vertices[0].rhw = 1.0f;
vertices[0].u = 0.0f;
vertices[0].v = static_cast<float>(inBuffer().height) / textRes;
vertices[1].x = xoffset - 0.5f;
vertices[1].y = yoffset - 0.5f;
vertices[1].z = 0.0f;
vertices[1].rhw = 1.0f;
vertices[1].u = 0.0f;
vertices[1].v = 0.0f;
vertices[2].x = xoffset + width() - 0.5f;
vertices[2].y = yoffset + height() - 0.5f;
vertices[2].z = 0.0f;
vertices[2].rhw = 1.0f;
vertices[2].u = static_cast<float>(inBuffer().width) / textRes;
vertices[2].v = static_cast<float>(inBuffer().height) / textRes;
vertices[3].x = xoffset + width() - 0.5f;
vertices[3].y = yoffset - 0.5f;
vertices[3].z = 0.0f;
vertices[3].rhw = 1.0f;
vertices[3].u = static_cast<float>(inBuffer().width) / textRes;
vertices[3].v = 0.0f;
vertexBuffer->Unlock();
} else
void NAbstractWaveformBuilder::cacheLoad()
{
QFile cache(m_cacheFile);
if (!m_cacheLoaded && cache.exists()) {
QByteArray compressed;
cache.open(QIODevice::ReadOnly);
QDataStream inFile(&cache);
inFile >> compressed;
cache.close();
QByteArray buffer = qUncompress(compressed);
QDataStream inBuffer(&buffer, QIODevice::ReadOnly);
inBuffer >> m_peaksCache >> m_dateHash;
m_cacheLoaded = TRUE;
}
void testIppResize3()
{
WHistogramParameter parameter
= WHistogramParameter()
.allChannel()
.range(0,255);
WHistogramResult<int, 3> histogram;
WImageBufferT<uchar, 3> inBuffer(640,480);
WConstImageT<uchar, 3> inImage = inBuffer;
IppHistogramParameter<3> ippParam = parameter;
histogram.resize(ippParam.levelsCount());
IPPIP::ippiHistogramRange_C3R(inImage, //(const uchar*)inImage,
inImage.step(),
inImage.ippRoiSize(),
histogram.getDataRef(),
ippParam.levels(),
ippParam.levelsCount());
}
void CGameServerState::dataPacketReceived(Net::CPaquete* packet) {
// Obtenemos la id de la conexion por la que hemos recibido
// el paquete (para identificar al cliente)
Net::NetID playerNetId = packet->getConexion()->getId();
// Construimos un buffer para leer los datos que hemos recibido
Net::CBuffer inBuffer( packet->getDataLength() );
inBuffer.write( packet->getData(), packet->getDataLength() );
inBuffer.reset(); // Desplazamos el puntero al principio para realizar la lectura
// En primer lugar extraemos el tipo del mensaje que hemos recibido
Net::NetMessageType msgType;
inBuffer.read( &msgType, sizeof(msgType) );
switch(msgType) {
case Net::PLAYER_INFO: {
// Deserializamos el nombre del player
std::string playerNick;
inBuffer.deserialize(playerNick);
//comprobamos si hay algún jugador con el mismo nombre en la partida, y si es así,
//se lo cambiamos para que no haya problemas en el futuro
if(_map->getEntityByName(playerNick)){
std::ostringstream convert;
convert << playerNetId;
std::string nameId = convert.str();
playerNick += nameId;
}
// Registramos al player en el gestor de jugadores
_playersMgr->addPlayer(playerNetId, playerNick);
// Enviamos la informacion de carga de mapa al cliente
sendMapInfo(playerNetId);
break;
}
case Net::MAP_LOADED: {
Net::CBuffer gameSettingsBuffer;
Net::NetMessageType msgType = Net::GAME_SETTINGS;
gameSettingsBuffer.write(&msgType, sizeof(msgType));
gameSettingsBuffer.write(&_gameMode, sizeof(_gameMode));
gameSettingsBuffer.write(&_gameTime, sizeof(_gameTime));
gameSettingsBuffer.write(&_goalScore, sizeof(_goalScore));
_netMgr->sendTo( playerNetId, gameSettingsBuffer.getbuffer(), gameSettingsBuffer.getSize() );
break;
}
case Net::GAME_SETTINGS_LOADED: {
// Una vez cargado el mapa, comienza la fase de carga de players.
// El player que esta siendo conectado deberá cargar a todos los players que ya estaban online.
sendWorldState(playerNetId);
break;
}
case Net::WORLD_STATE_LOADED: {
Net::NetMessageType startGameMsg = Net::START_GAME;
_netMgr->sendTo(playerNetId, &startGameMsg, sizeof(startGameMsg));
break;
}
case Net::CLASS_SELECTED: {
int race;
inBuffer.deserialize(race);
if(race == 5) {
unsigned int nbSpectators = 0;
for(auto it = _playersMgr->begin(); it != _playersMgr->end(); ++it) {
std::pair<Logic::TEntityID, bool> id = _playersMgr->getPlayerId(playerNetId);
if(id.second) {
if(Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(id.first)->getType() == "Spectator")
++nbSpectators;
}
}
if(nbSpectators < _maxSpectators) {
// Creamos una entidad espectador y la replicamos en el cliente
createAndMirrorSpectator(playerNetId);
}
else {
// Mandamos un mensaje de que no existen slots disponibles
// para jugar
Net::NetMessageType noSlotsMsg = Net::NO_FREE_SPECTATOR_SLOTS;
Net::CBuffer errorBuffer( sizeof(noSlotsMsg) );
errorBuffer.write( &noSlotsMsg, sizeof(noSlotsMsg) );
_netMgr->sendTo(playerNetId, errorBuffer.getbuffer(), errorBuffer.getSize());
}
}
else {
// Si quedan slots para conectarse como jugador permitimos que
// se conecte, sino le mandamos un mensaje
bool isChanging = false;
if( _playersMgr->existsByNetId(playerNetId) ) {
isChanging = _playersMgr->getPlayer(playerNetId).isSpawned();
}
// Si estamos cambiando de clase, consideramos un jugador menos, ya que
// nosotros si no contariamos
unsigned nbPlayersPlaying = _playersMgr->getNumberOfPlayersSpawned();
if(isChanging)
--nbPlayersPlaying;
if( nbPlayersPlaying < _maxPlayers) {
Logic::TeamFaction::Enum team;
if(_autoBalanceTeams) {
if(_playersMgr->blueTeamPlayers() < _playersMgr->redTeamPlayers()) {
team = Logic::TeamFaction::eBLUE_TEAM;
}
else {
team = Logic::TeamFaction::eRED_TEAM;
}
}
else {
if(_gameMode == GameMode::eTEAM_DEATHMATCH ||
_gameMode == GameMode::eCAPTURE_THE_FLAG) {
inBuffer.read(&team, sizeof(team));
}
else {
team = Logic::TeamFaction::eNONE;
}
}
// Creamos una entidad jugador con la clase que nos hayan dicho
// y la replicamos en el cliente
createAndMirrorPlayer(race, playerNetId, team);
}
else {
// Mandamos un mensaje de que no existen slots disponibles
// para jugar
Net::NetMessageType noSlotsMsg = Net::NO_FREE_PLAYER_SLOTS;
Net::CBuffer errorBuffer( sizeof(noSlotsMsg) );
errorBuffer.write( &noSlotsMsg, sizeof(noSlotsMsg) );
_netMgr->sendTo(playerNetId, errorBuffer.getbuffer(), errorBuffer.getSize());
}
}
break;
}
case Net::PING: {
Net::NetMessageType ackMsg = Net::PING;
clock_t time = clock();
Net::CBuffer ackBuffer(sizeof(ackMsg) + sizeof(time));
ackBuffer.write(&ackMsg, sizeof(ackMsg));
ackBuffer.write(&time, sizeof(time));
_netMgr->sendTo(playerNetId, ackBuffer.getbuffer(), ackBuffer.getSize());
break;
}
case Net::LOCAL_PLAYER_LOADED:
{
Logic::TEntityID id;
inBuffer.deserialize(id);
Logic::CEntity* player = _map->getEntityByID(id);
player->activate();
player->start();
break;
}
}
} // dataPacketReceived
AbstractFilter::FilterResult SAAFilter::ProcessMessage( AbstractFilter::buffer_type inputData, AbstractFilter::buffer_type outputData, NameValueCollection& transportHeaders, bool asClient )
{
ManagedBuffer *inputBuffer = inputData.get();
string groupId = transportHeaders[ MqFilter::MQGROUPID ];
if( !asClient )
{
if ( inputBuffer )
{
DEBUG( "Applying SAA filter..." );
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* doc = NULL;
char* outputXslt = NULL;
try
{
const string& payload = inputBuffer->str();
doc = XmlUtil::DeserializeFromString( payload );
XSLTFilter xsltFilter;
xsltFilter.ProcessMessage( doc, reinterpret_cast< unsigned char** >( &outputXslt), transportHeaders, true );
size_t outputXsltSize = strlen( outputXslt );
WorkItem< ManagedBuffer > inBuffer( new ManagedBuffer( reinterpret_cast<unsigned char*> ( outputXslt ), ManagedBuffer::Ref, outputXsltSize) );
WorkItem< ManagedBuffer > outBuffer( new ManagedBuffer() );
SwiftFormatFilter swiftFormatFilter;
swiftFormatFilter.ProcessMessage( inBuffer, outBuffer, transportHeaders, false );
BatchItem item;
m_BatchStorage->open( groupId, ios_base::out );
item.setBinPayload( outBuffer.get() );
item.setBatchId( groupId );
item.setSequence( 1 );
*m_BatchStorage << item;
item.setSequence( 2 );
item.setLast();
item.setPayload( payload );
*m_BatchStorage << item;
}
catch( ... )
{
if ( doc != NULL )
doc->release();
delete outputXslt;
TRACE( "Unhandled exception while applying SAA filter");
throw;
}
doc->release();
delete outputXslt;
return SAAFilter::Completed;
}
}
else
{
DEBUG( "Applying SAA filter ..." );
WorkItem< ManagedBuffer > outputBuffer( new ManagedBuffer() );
ManagedBuffer* managedOutputData = outputData.get();
WorkItem< ManagedBuffer > inputBuffer( new ManagedBuffer() );
ManagedBuffer* managedInputBuffer = inputBuffer.get();
m_BatchStorage->open( Base64::decode( groupId ), ios_base::in );
BatchItem batchItem;
bool backoutCountExceeds = false;
try
{
//get partner message
*m_BatchStorage >> batchItem;
managedInputBuffer->copyFrom( batchItem.getPayload() );
//check backout count
// TODO: Change backout count expose mechanism to avoid cast
BatchManager<BatchMQStorage>* castStorage = dynamic_cast< BatchManager<BatchMQStorage> * >( m_BatchStorage.get() );
if( castStorage != NULL )
{
//backout count exceeded, try Abort
if( castStorage->storage().getCleaningUp() )
{
*m_BatchStorage >> batchItem;
managedOutputData->copyFrom( batchItem.getPayload() );
// Dont't rely on filter user to Abort;
// The commit is save because SAAFilter-server is always the first stage of message processing
// ( nothing is partial commited when backout count exceeded)
castStorage->storage().setCleaningUp( false );
m_BatchStorage->commit();
AppException aex( "FileAct message moved to dead letter queue because backout count exceeded" );
aex.setSeverity( EventSeverity::Fatal );
throw aex;
}
}
else
TRACE( "Backout counts should be check here..." )
//check signature in partner message
SwiftFormatFilter swiftFormatFilter;
swiftFormatFilter.ProcessMessage( inputBuffer, outputBuffer, transportHeaders, true );
}
catch( runtime_error &ex )
