bool gkMouseNode::evaluate(gkScalar tick)
{
gkMouse* dev = gkWindowSystem::getSingleton().getMouse();
gkScalar x = 0, y = 0;
gkScalar x_scale = GET_SOCKET_VALUE(SCALE_X);
gkScalar y_scale = GET_SOCKET_VALUE(SCALE_Y);
if (dev->moved)
{
if (GET_SOCKET(REL_X)->isConnected()) x = dev->relative.x * x_scale;
if (GET_SOCKET(REL_Y)->isConnected()) y = dev->relative.y * y_scale;
}
if (GET_SOCKET(ABS_X)->isConnected()) SET_SOCKET_VALUE(ABS_X, dev->position.x * x_scale);
if (GET_SOCKET(ABS_Y)->isConnected()) SET_SOCKET_VALUE(ABS_Y, dev->position.y * y_scale);
SET_SOCKET_VALUE(REL_X, x);
SET_SOCKET_VALUE(REL_Y, y);
SET_SOCKET_VALUE(MOTION, dev->moved);
SET_SOCKET_VALUE(WHEEL, dev->wheelDelta);
SET_SOCKET_VALUE(WHEEL_MOTION, dev->wheelDelta ? true : false);
return false;
}
static int _tcp_connect(network_context_t *ctx)
{
network_context_socket_tcp_t *tcp_io_ctx;
assert(ctx);
tcp_io_ctx = (network_context_socket_tcp_t *) ctx->impl_data;
assert(tcp_io_ctx);
PTHREAD_CALL(pthread_mutex_lock(&tcp_io_ctx->connect_lock));
if (!tcp_io_ctx->connected)
{
assert(ctx->peer_addr_valid);
assert(ctx->peer_addr.sa_family == AF_INET);
assert(((struct sockaddr_in *) &ctx->peer_addr)->sin_port > 0);
DEBUG_LOG(("_tcp_connect (my_sd=%d): connecting on socket %d...\n",
tcp_io_ctx->sock_ctx->my_sd, (int)GET_SOCKET(ctx)));
if ((connect(GET_SOCKET(ctx), &ctx->peer_addr,
sizeof(ctx->peer_addr))) < 0)
{
perror("connect (_tcp_connect)");
fprintf(stderr, "(errno=%d)\n", errno);
return -1;
}
tcp_io_ctx->connected = TRUE;
}
PTHREAD_CALL(pthread_mutex_unlock(&tcp_io_ctx->connect_lock));
return 0;
}
/* send the given packet to the peer */
ssize_t _network_send_packet(network_context_t *ctx,
const void *src, size_t len)
{
network_context_socket_tcp_t *tcp_io_ctx;
uint16_t packet_len; /* network byte order */
assert(ctx && src);
assert(ctx->peer_addr_len > 0);
tcp_io_ctx = (network_context_socket_tcp_t *) ctx->impl_data;
assert(tcp_io_ctx);
VERIFY_SOCKET(ctx);
DEBUG_PEER(ctx);
if (_tcp_connect(ctx) < 0)
return -1;
packet_len = htons(len);
if (_tcp_io(GET_SOCKET(ctx), &packet_len, sizeof(packet_len),
(io_func_t) write) < 0 ||
_tcp_io(GET_SOCKET(ctx), (void *) src, len, (io_func_t) write) < 0)
return -1;
/* printf("network send: %lu\n", len); */
return len;
}
int _network_listen(network_context_t *ctx, int backlog)
{
assert(ctx);
VERIFY_SOCKET(ctx);
return listen(GET_SOCKET(ctx), backlog);
}
bool gkVariableNode::evaluate(gkScalar tick)
{
if (!m_prop) return false;
SET_SOCKET_VALUE(RESULT, *m_prop);
if (!GET_SOCKET(SET)->isLinked() && !GET_SOCKET(VALUE)->isLinked())
{
// variable will not change
return false;
}
if (GET_SOCKET_VALUE(SET))
m_prop->setValue(GET_SOCKET_VALUE(VALUE));
return false;
}
void VariableOpNode::initialize()
{
if (!m_varName.empty())
{
gkGameObject* ob = GET_SOCKET(SET)->getGameObject();
if (ob != 0)
m_prop = ob->getVariable(m_varName);
}
}
void gkVariableNode::initialize()
{
if (!m_varName.empty())
{
gkGameObject* ob = GET_SOCKET(SET)->getGameObject();
if (ob != 0)
{
if (!ob->hasVariable(m_varName))
m_prop = ob->createVariable(m_varName, m_debug);
else
m_prop = ob->getVariable(m_varName);
if (m_prop && GET_SOCKET_VALUE(SET))
m_prop->setValue(GET_SOCKET_VALUE(VALUE));
}
}
}
/* read a packet from the peer */
ssize_t _network_recv_packet(network_context_t *ctx, void *dst, size_t max_len)
{
network_context_socket_tcp_t *tcp_io_ctx;
uint16_t packet_len;
socket_t io_socket;
int rc;
assert(ctx && dst);
tcp_io_ctx = (network_context_socket_tcp_t *) ctx->impl_data;
assert(tcp_io_ctx);
assert(tcp_io_ctx->sock_ctx);
VERIFY_SOCKET(ctx);
io_socket = tcp_io_ctx->base.socket;
if (tcp_io_ctx->sock_ctx->is_active && _tcp_connect(ctx) < 0)
return -1;
if (tcp_io_ctx->sock_ctx->listening/* ||
(tcp_io_ctx->sock_ctx->is_active && !tcp_io_ctx->connected)*/)
{
socket_t tmp_sd;
ctx->peer_addr_len = sizeof(ctx->peer_addr);
if ((tmp_sd = accept(GET_SOCKET(ctx),
&ctx->peer_addr,
&ctx->peer_addr_len)) < 0)
{
perror("accept (network_io_tcp)");
return tmp_sd;
}
DEBUG_LOG(("accepted from peer, tmp_sd=%d...\n", (int) tmp_sd));
/* keep listening socket open for futher connection requests */
/* we will not reenter this function until this SYN packet has
* been dispatched to the right context, and that context's
* socket updated to be 'new_socket'
*/
assert(tcp_io_ctx->new_socket == -1);
tcp_io_ctx->new_socket = tmp_sd;
io_socket = tmp_sd;
}
DEBUG_PEER(ctx);
#ifdef DEBUG
if (getpeername(io_socket, &ctx->peer_addr, &ctx->peer_addr_len) < 0)
{
DEBUG_LOG(("getpeername failed (errno=%d)\n", errno));
return -1;
}
#endif
if ((rc = _tcp_io(io_socket, &packet_len, sizeof(packet_len), read)) <= 0)
{
DEBUG_LOG(("couldn't read packet len: %d\n", rc));
return rc;
}
packet_len = ntohs(packet_len);
if ((rc = _tcp_io(io_socket, dst, MIN(packet_len, max_len), read)) <= 0)
{
DEBUG_LOG(("couldn't read packet: %d\n", rc));
return rc;
}
if (packet_len > max_len)
{
/* discard unread remainder of packet */
char *dummy = (char *) alloca(packet_len - max_len);
(void) _tcp_io(io_socket, dummy, packet_len - max_len, read);
}
/* printf("network_recv_packet: %d\n", packet_len); */
return packet_len;
}
