//----------------------------------------------------------------------
// connect
//----------------------------------------------------------------------
bool PipeConnection::connect()
{
LBASSERT( getDescription()->type == CONNECTIONTYPE_PIPE );
if( !isClosed( ))
return false;
_setState( STATE_CONNECTING );
_sibling = new PipeConnection;
_sibling->_sibling = this;
if( !_createPipes( ))
{
close();
return false;
}
_setState( STATE_CONNECTED );
_sibling->_setState( STATE_CONNECTED );
return true;
}
void BZSpriteStarHolder::onUpdate()
{
BZSpriteCommon::onUpdate();
switch (_getState())
{
case ESHS_Blank:
break;
case ESHS_Filling:
{
int n = 0;
CASprite* psprsRemoved[256];
CAObject* pobj;
CCARRAY_FOREACH(_pieces, pobj)
{
CASprite* pspr = (CASprite*)pobj;
float p0 = pspr->getAnimationPercent(this->layer()->getTimeNow());
float p = p0 + 0.1f;
if (p > 1.0f) p = 1.0f;
CCPoint pos;
CCPoint posBegin = pspr->getPos();
CCPoint posTo = getPos();
pos.x = posBegin.x + (posTo.x - posBegin.x) * p;
pos.y = posBegin.y + (posTo.y - posBegin.y) * p;
_Info("star (%.2f) (%.2f,%.2f) (%.2f,%.2f) (%.2f,%.2f)", p0, pos.x, pos.y, posBegin.x, posBegin.y, posTo.x, posTo.y);
pspr->setPos(pos);
if (pspr->isAnimationDone())
{
pspr->setPos(posTo);
pspr->killMyself();
psprsRemoved[n++] = pspr;
this->setState("on");
_setState(ESHS_Filled);
}
}
while (n > 0)
{
CASprite* pspr = psprsRemoved[n - 1];
_pieces->removeObject(pspr);
n--;
}
}
break;
case ESHS_Filled:
break;
}
void EventConnection::_close()
{
#ifdef _WIN32
if( _event )
CloseHandle( _event );
_event = 0;
#else
if( _connection.isValid( ))
_connection->close();
_connection = 0;
_set = false;
#endif
_setState( STATE_CLOSED );
}
void BZSpriteStarHolder::addStar(const string& name, const CCPoint& pos)
{
_Assert(ESHS_Blank == _item_state);
CAStageLayer* pl = this->layer();
CASprite* pspr = CAWorld::sharedWorld()->createSprite(pl, name.c_str());
pspr->setVertexZ(this->getVertexZ() + 10.0f);
pspr->setPos(pos);
pspr->setState("fly");
pl->addSprite(pspr);
_pieces->addObject(pspr);
CCPoint pp = pspr->getPos();
_Info("star pos (%.2f,%.2f), inpos (%.2f,%.2f)", pp.x, pp.y, pos.x, pos.y);
_setState(ESHS_Filling);
}
void PipeConnection::_close()
{
if( isClosed( ))
return;
if( _writeFD > 0 )
{
::close( _writeFD );
_writeFD = 0;
}
if( _readFD > 0 )
{
::close( _readFD );
_readFD = 0;
}
_setState( STATE_CLOSED );
_sibling = 0;
}
//==============================================================================
GlBufferHandle::GlBufferHandle(GlCommandBufferHandle& commands,
GLenum target, PtrSize size, GLenum flags)
{
ANKI_ASSERT(!isCreated());
using Alloc = GlGlobalHeapAllocator<GlBuffer>;
using DeleteCommand =
GlDeleteObjectCommand<GlBuffer, GlGlobalHeapAllocator<U8>>;
using Deleter = GlHandleDeferredDeleter<GlBuffer, Alloc, DeleteCommand>;
*static_cast<Base::Base*>(this) = Base::Base(
&commands._getQueue().getDevice(),
commands._getQueue().getDevice()._getAllocator(),
Deleter());
_setState(GlHandleState::TO_BE_CREATED);
// Fire the command
commands._pushBackNewCommand<GlBufferCreateCommand>(
*this, target, size, flags);
}
void Button::updateButtonState()
{
if (mStateSelected)
{
if (!getEnabled())
{
if (!_setState("disabled_checked"))
_setState("disabled");
}
else if (mIsMousePressed)
{
if (!_setState("pushed_checked"))
_setState("pushed");
}
else if (mIsMouseFocus)
{
if (!_setState("highlighted_checked"))
_setState("pushed");
}
else
_setState("normal_checked");
}
else
{
if (!getEnabled())
_setState("disabled");
else if (mIsMousePressed)
_setState("pushed");
else if (mIsMouseFocus)
_setState("highlighted");
else
_setState("normal");
}
}
void Widget::_receive( Msg * _pMsg )
{
State state = m_state;
switch( _pMsg->type() )
{
case MsgType::MouseEnter:
if( m_bPressed )
state.setPressed(true);
else
state.setHovered(true);
break;
case MsgType::MouseLeave:
state.setHovered(false); // Also clears any pressed flag.
break;
case MsgType::MousePress:
{
auto pMsg = static_cast<MousePressMsg*>(_pMsg);
if( pMsg->button() == MouseButton::Left )
{
if( state.isHovered() )
state.setPressed(true);
m_bPressed = true;
}
break;
}
case MsgType::MouseRelease:
{
auto pMsg = static_cast<MouseReleaseMsg*>(_pMsg);
if( pMsg->button() == MouseButton::Left )
{
if( state.isHovered() )
state.setPressed(false);
m_bPressed = false;
}
break;
}
case MsgType::FocusGained:
state.setFocused(true);
break;
case MsgType::FocusLost:
state.setFocused(false);
break;
case MsgType::DropPick:
{
auto pMsg = static_cast<DropPickMsg*>(_pMsg);
if (!pMsg->hasPayload())
{
pMsg->setPayload(Payload::create());
}
break;
}
case MsgType::DropEnter:
state.setTargeted(true);
break;
case MsgType::DropLeave:
state.setTargeted(false);
break;
default:
break;
}
if( state != m_state )
_setState( state );
}
void CObject3D::_renderSkin(const GMObject& obj, const D3DXMATRIX* world, int alpha)
{
D3DXMATRIX* bones, *invBones;
D3DXMATRIX mat;
int i, nID, j;
if (m_externBones)
{
bones = m_externBones;
invBones = m_externInvBones;
}
else
{
bones = m_baseBones;
invBones = m_baseInvBones;
}
if (obj.usedBoneCount)
{
for (i = 0; i < obj.usedBoneCount; i++)
{
nID = obj.usedBones[i];
mat = invBones[nID] * bones[nID];
D3DXMatrixTranspose(&mat, &mat);
m_device->SetVertexShaderConstantF(i * 3, (float*)&mat, 3);
}
}
m_device->SetVertexDeclaration(s_skinVertexDeclaration);
m_device->SetVertexShader(s_skinVS);
m_device->SetStreamSource(0, obj.VB, 0, sizeof(SkinVertex));
m_device->SetIndices(obj.IB);
m_device->SetTransform(D3DTS_WORLD, world);
for (i = 0; i < obj.materialBlockCount; i++)
{
const MaterialBlock& block = obj.materialBlocks[i];
if (block.usedBoneCount)
{
for (j = 0; j < block.usedBoneCount; j++)
{
nID = block.usedBones[j];
mat = invBones[nID] * bones[nID];
D3DXMatrixTranspose(&mat, &mat);
m_device->SetVertexShaderConstantF(j * 3, (float*)&mat, 3);
}
}
_setState(block, alpha);
if (obj.material)
{
const CTexture* texture = obj.materials[block.materialID].textures[m_group->currentTextureEx];
if (texture)
m_device->SetTexture(0, *texture);
else
m_device->SetTexture(0, null);
}
else
m_device->SetTexture(0, null);
m_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, obj.vertexCount, block.startVertex, block.primitiveCount);
_resetState(block, alpha);
}
m_device->SetVertexShader(null);
m_device->SetVertexDeclaration(null);
}
//----------------------------------------------------------------------
// listen
//----------------------------------------------------------------------
bool SocketConnection::listen()
{
ConnectionDescriptionPtr description = _getDescription();
LBASSERT( description->type == CONNECTIONTYPE_TCPIP );
if( !isClosed( ))
return false;
_setState( STATE_CONNECTING );
sockaddr_in address;
const size_t size = sizeof( sockaddr_in );
if( !_parseAddress( description, address ))
{
LBWARN << "Can't parse connection parameters" << std::endl;
return false;
}
if( !_createSocket())
return false;
const bool bound = (::bind( _readFD, (sockaddr *)&address, size ) == 0);
if( !bound )
{
LBWARN << "Could not bind socket " << _readFD << ": "
<< lunchbox::sysError << " to " << getHostName( address )
<< ":" << ntohs( address.sin_port ) << " AF "
<< (int)address.sin_family << std::endl;
close();
return false;
}
if( ::listen( _readFD, SOMAXCONN ) != 0 )
{
LBWARN << "Could not listen on socket: " << lunchbox::sysError
<< std::endl;
close();
return false;
}
// get socket parameters
socklen_t used = size;
getsockname( _readFD, (struct sockaddr *)&address, &used );
description->port = ntohs( address.sin_port );
std::string hostname = description->getHostname();
if( hostname.empty( ))
{
if( address.sin_addr.s_addr == INADDR_ANY )
{
char cHostname[256] = {0};
gethostname( cHostname, 256 );
hostname = cHostname;
description->setHostname( hostname );
}
else
description->setHostname( getHostName( address ));
}
_initAIOAccept();
_setState( STATE_LISTENING );
LBDEBUG << "Listening on " << description->getHostname() << "["
<< getHostName( address ) << "]:" << description->port
<< " (" << description->toString() << ")" << std::endl;
return true;
}
//----------------------------------------------------------------------
// connect
//----------------------------------------------------------------------
bool SocketConnection::connect()
{
ConnectionDescriptionPtr description = _getDescription();
LBASSERT( description->type == CONNECTIONTYPE_TCPIP );
if( !isClosed( ))
return false;
if( description->port == 0 )
return false;
if( description->getHostname().empty( ))
description->setHostname( "127.0.0.1" );
sockaddr_in address;
if( !_parseAddress( description, address ))
{
LBWARN << "Can't parse connection parameters" << std::endl;
return false;
}
_setState( STATE_CONNECTING );
if( !_createSocket( ))
return false;
if( address.sin_addr.s_addr == 0 )
{
LBWARN << "Refuse to connect to 0.0.0.0" << std::endl;
close();
return false;
}
#ifdef _WIN32
const bool connected = WSAConnect( _readFD, (sockaddr*)&address,
sizeof( address ), 0, 0, 0, 0 ) == 0;
#else
int nTries = 10;
while( nTries-- )
{
const bool connected = (::connect( _readFD, (sockaddr*)&address,
sizeof( address )) == 0);
if( connected )
break;
switch( errno )
{
case EINTR: // Happens sometimes, but looks harmless
LBDEBUG << "connect: " << lunchbox::sysError << ", retrying"
<< std::endl;
lunchbox::sleep( 5 /*ms*/ );
break;
default:
nTries = 0;
break;
}
}
const bool connected = nTries > 0;
#endif
if( !connected )
{
LBDEBUG << "Could not connect to '" << description->getHostname() << ":"
<< description->port << "': " << lunchbox::sysError << std::endl;
close();
return false;
}
_initAIORead();
_setState( STATE_CONNECTED );
LBDEBUG << "Connected " << description->toString() << std::endl;
return true;
}
void BZSpriteStarHolder::reset()
{
this->setState("off");
_setState(ESHS_Blank);
}
void Button::_receive( const Msg_p& _pMsg )
{
State state = m_state;
MsgRouter_p pHandler = Base::msgRouter();
switch( _pMsg->type() )
{
case MsgType::KeyPress:
if( KeyPressMsg::cast(_pMsg)->translatedKeyCode() == Key::Return )
{
m_bReturnPressed = true;
_pMsg->swallow();
}
break;
case MsgType::KeyRepeat:
if( KeyRepeatMsg::cast(_pMsg)->translatedKeyCode() == Key::Return )
_pMsg->swallow();
break;
case MsgType::KeyRelease:
if( KeyReleaseMsg::cast(_pMsg)->translatedKeyCode() == Key::Return )
{
m_bReturnPressed = false;
pHandler->post( new SelectMsg(this) );
_pMsg->swallow();
}
break;
case MsgType::MouseEnter:
state.setHovered(true);
break;
case MsgType::MouseLeave:
state.setHovered(false);
break;
case MsgType::MousePress:
if( MousePressMsg::cast(_pMsg)->button() == MouseButton::Left )
{
m_bPressed = true;
_pMsg->swallow();
}
break;
case MsgType::MouseRelease:
if( MouseReleaseMsg::cast(_pMsg)->button() == MouseButton::Left )
{
m_bPressed = false;
_pMsg->swallow();
}
break;
case MsgType::MouseClick:
if( MouseClickMsg::cast(_pMsg)->button() == MouseButton::Left )
{
pHandler->post( new SelectMsg(this) );
_pMsg->swallow();
}
break;
case MsgType::MouseDoubleClick:
case MsgType::MouseRepeat:
case MsgType::MouseDrag:
if( MouseButtonMsg::cast(_pMsg)->button() == MouseButton::Left )
_pMsg->swallow();
break;
case MsgType::FocusGained:
state.setFocused(true);
break;
case MsgType::FocusLost:
state.setFocused(false);
m_bReturnPressed = false;
m_bPressed = false;
break;
default:
break;
}
if( m_bReturnPressed || (m_bPressed && (m_bDownOutside || state.isHovered() )) )
state.setPressed(true);
else
state.setPressed(false);
if( state != m_state )
_setState(state);
}
