void IOServiceLibEvent::send(const ChannelId& id,
const std::list<mxcore::SharedPtr<mxcore::ByteBuffer> > messageList,
int perMsgTimeout)
{
ChannelContext* ctx = findChannel(id);
MX_ASSERT(NULL != ctx);
MX_ASSERT(ctx->isConnector());
for (std::list<mxcore::SharedPtr<mxcore::ByteBuffer> >::const_iterator it =
messageList.begin(); it != messageList.end(); it++)
{
MX_ASSERT((*it)->remaining() > 0);
}
ConnectorChannelContext* connectorCtx = (ConnectorChannelContext*) ctx;
bool haveMessage = connectorCtx->haveMessageToWrite();
connectorCtx->putWriteMessage(messageList, perMsgTimeout);
if (!haveMessage)
{
connectorCtx->registWrite();
connectorCtx->registWriteTimer(perMsgTimeout);
}
}
bool HttpVirtualServer::addServlet(const std::string& path,
mxcore::SharedPtr<HttpServlet> servlet)
{
MX_ASSERT(!path.empty());
MX_ASSERT(!servlet.isNull());
ServletMap::const_iterator it = servlets_.find(path);
if (it != servlets_.end())
{
return false;
}
pcre* re = mxhttp::PcreUtil::open(path);
if (NULL == re)
{
return false;
}
servlets_.insert(std::make_pair(path, servlet));
pcres_.insert(std::make_pair(re, servlet));
return true;
}
MessageBuffer& MessageBuffer::put(const void* data, uint32_t len)
{
MX_ASSERT(NULL != data && len > 0);
MX_ASSERT(len <= writable());
return putImpl(data, len);
}
void mx_LevelGenerator::AddConnectionCube( const Connection* connection )
{
const unsigned int c_side_count= 4;
ReserveTrianglesAndVertices( c_side_count * 2, c_side_count * 4 );
MX_ASSERT( out_level_data_.vertex_count + c_side_count * 4 <= out_level_data_.vertices_capacity );
MX_ASSERT( out_level_data_.triangle_count + c_side_count * 2 < out_level_data_.triangles_capacity );
float min_max[2][3]; // 0 - min, 1 - max
for( unsigned int i= 0; i < 3; i++ )
{
float b= float(connection->coord_begin[i]);
float e= float(connection->coord_end[i]);
if( b > e )
min_max[0][i]= e, min_max[1][i]= b;
else
min_max[0][i]= b, min_max[1][i]= e;
min_max[1][i]++;
}
unsigned int skip_side;
if( connection->coord_begin[0] != connection->coord_end[0] )
skip_side= 0;
else if( connection->coord_begin[1] != connection->coord_end[1] )
skip_side= 1;
else
{
skip_side= 2;
MX_ASSERT( connection->coord_begin[2] != connection->coord_end[2] );
}
mx_LevelVertex* v= out_level_data_.vertices + out_level_data_.vertex_count;
for( unsigned int i= 0; i < 4 * 6; i++ )
{
if( i / 8u == skip_side ) continue;
const unsigned char *c= c_cube_vertices + 3 * i;
v->xyz[0]= min_max[ c[0] ][0];
v->xyz[1]= min_max[ c[1] ][1];
v->xyz[2]= min_max[ c[2] ][2];
v++;
}
mx_LevelTriangle* triangle= out_level_data_.triangles + out_level_data_.triangle_count;
for(
unsigned int i= out_level_data_.vertex_count;
i < out_level_data_.vertex_count + c_side_count * 4; i+=4, triangle+=2 )
{
triangle[0].vertex_index[0]= (i );
triangle[0].vertex_index[1]= (i + 1);
triangle[0].vertex_index[2]= (i + 2);
triangle[1].vertex_index[0]= (i );
triangle[1].vertex_index[1]= (i + 2);
triangle[1].vertex_index[2]= (i + 3);
}
out_level_data_.vertex_count+= c_side_count * 4;
out_level_data_.triangle_count+= c_side_count * 2;
}
uint32_t MessageBuffer::fullForGet(mxos::IOVEC* vec, uint32_t count) const
{
MX_ASSERT(NULL != vec && count > 0);
int rable = readable();
MX_ASSERT(rable > 0);
int len = capacity_ - readPos_;
if (len > rable)
{
len = rable;
}
vec[0].iov_base = buffer_ + readPos_;
vec[0].iov_len = len;
rable -= len;
if (rable > 0 && count > 1)
{
vec[1].iov_base = buffer_;
vec[1].iov_len = rable;
return 2;
}
return 1;
}
uint32_t MessageBuffer::fullForPut(mxos::IOVEC* vec, uint32_t count) const
{
MX_ASSERT(NULL != vec && count > 0);
int wable = writable();
MX_ASSERT(wable > 0);
int len = capacity_ - writePos_;
if (len > wable)
{
len = wable;
}
vec[0].iov_base = buffer_ + writePos_;
vec[0].iov_len = len;
wable -= len;
if (wable > 0 && count > 1)
{
vec[1].iov_base = buffer_;
vec[1].iov_len = wable;
return 2;
}
return 1;
}
void mx_LevelGenerator::PlaceRooms()
{
Room* room= rooms_;
{ // Place central room
for( unsigned int j= 0; j < 3; j++ )
{
room->coord_min[j]= MX_MAX_LEVEL_SIZE_CELLS / 2 - MX_CENTRAL_ROOM_HALF_SIZE;
room->coord_max[j]= MX_MAX_LEVEL_SIZE_CELLS / 2 + MX_CENTRAL_ROOM_HALF_SIZE;
}
for( int z= room->coord_min[2]; z < room->coord_max[2]; z++ )
for( int y= room->coord_min[1]; y < room->coord_max[1]; y++ )
for( int x= room->coord_min[0]; x < room->coord_max[0]; x++ )
ElementMap( x, y, z )= room;
room->connection_count= 0;
room++;
room_count_++;
}
for( unsigned int i= 1; i < MX_MAX_ROOMS * 2; i++ )
{
// Create room
for( unsigned int j= 0; j < 3; j++ )
{
room->coord_min[j]= rand_.RandI( 1, MX_MAX_LEVEL_SIZE_CELLS - MX_MAX_ROOM_SIZE - 1 );
room->coord_max[j]= room->coord_min[j] + rand_.RandI( MX_MIN_ROOM_SIZE, MX_MAX_ROOM_SIZE + 1 );
MX_ASSERT( room->coord_min[j] >= 1 && room->coord_min[j] < MX_MAX_LEVEL_SIZE_CELLS - 1 );
MX_ASSERT( room->coord_max[j] >= 1 && room->coord_max[j] < MX_MAX_LEVEL_SIZE_CELLS - 1 );
}
// Check free space
for( int z= std::max( 0, room->coord_min[2] - MX_MIN_ROOM_DISTANCE );
z < std::min( MX_MAX_LEVEL_SIZE_CELLS, room->coord_max[2] + MX_MIN_ROOM_DISTANCE );
z++ )
for( int y= std::max( 0, room->coord_min[1] - MX_MIN_ROOM_DISTANCE );
y < std::min( MX_MAX_LEVEL_SIZE_CELLS, room->coord_max[1] + MX_MIN_ROOM_DISTANCE );
y++ )
for( int x= std::max( 0, room->coord_min[0] - MX_MIN_ROOM_DISTANCE );
x < std::min( MX_MAX_LEVEL_SIZE_CELLS, room->coord_max[0] + MX_MIN_ROOM_DISTANCE );
x++ )
if( ElementMap( x, y, z ) != NULL )
goto failed;
// Mark space for this room
for( int z= room->coord_min[2]; z < room->coord_max[2]; z++ )
for( int y= room->coord_min[1]; y < room->coord_max[1]; y++ )
for( int x= room->coord_min[0]; x < room->coord_max[0]; x++ )
ElementMap( x, y, z )= room;
room->connection_count= 0;
room++;
room_count_++;
if( room_count_ == MX_MAX_ROOMS ) break;
failed:;
}
}
void mxface_init( MxFace *f, MxVertexID v0, MxVertexID v1, MxVertexID v2 )
{
MX_ASSERT( v0 != v1 );
MX_ASSERT( v1 != v2 );
MX_ASSERT( v2 != v0 );
f->v[0] = v0;
f->v[1] = v1;
f->v[2] = v2;
}
static void swapb_big( Block *b, int i, int j, void *place1, void *place2 )
{
void *temp = MX_ALLOC ( b->size_each );
MX_ASSERT( i >= 0 && i < b->used );
MX_ASSERT( j >= 0 && j < b->used );
MX_COPY (place1, b->size_each, temp);
MX_COPY (place2, b->size_each, place1);
MX_COPY (temp, b->size_each, place2);
MX_FREE( temp, b->size_each );
}
void mx_LevelGenerator::Generate()
{
MX_ASSERT( room_count_ == 0 );
MX_ASSERT( connection_count_ == 0 );
PlaceRooms();
PlaceConnections();
CalculateLinkage();
GenerateMeshes();
CalculateNormals();
CalculateTextureCoordinates();
SetupTextures();
}
static bool getAddrInfo(const char* hostname, int af, void* addr, int* addr_len)
{
bool ret = false;
struct addrinfo hints;
struct addrinfo* res = NULL;
MX_ASSERT(NULL != hostname);
::memset(&hints, 0, sizeof(hints));
hints.ai_family = af;
if (0 == ::getaddrinfo(hostname, NULL, &hints, &res) && (res->ai_addrlen
<= sizeof(struct sockaddr_in6)))
{
ret = true;
*addr_len = res->ai_addrlen;
::memcpy(addr, res->ai_addr, res->ai_addrlen);
}
if (NULL != res)
{
::freeaddrinfo(res);
}
return ret;
}
MessageBuffer& MessageBuffer::put(uint64_t value)
{
MX_ASSERT(writable() >= sizeof(value));
uint64_t orderValue = ByteOrder::NATIVE_ORDER.toOrder(value, byteOrder_);
return putImpl(&orderValue, sizeof(orderValue));
}
void SocketAddress::set(const char* hostname, int family, uint16_t port)
throw (UnknownHostException)
{
int addrLen = 0;
MX_ASSERT(NULL != hostname);
if (AF_UNSPEC == family)
{
if (!getAddrInfo(hostname, AF_INET6, &data_, &addrLen) && !getAddrInfo(
hostname, AF_INET, &data_, &addrLen))
{
THROW2(UnknownHostException, std::string("Unknown hostname: [") + hostname + "]");
}
}
else
{
if (!getAddrInfo(hostname, family, &data_, &addrLen))
{
THROW2(UnknownHostException, std::string("Unknown hostname: [") + hostname + "]");
}
}
setPort(port);
}
bool ServerSocket::accept(Socket& client) throw (IOException&)
{
MX_ASSERT(!isClosed());
int sock = mxos::accept(handle_, NULL, NULL);
if (-1 == sock)
{
int err = mxos::getLastSocketError();
#if defined(WIN32)
if (WSAEWOULDBLOCK == err || WSAEINTR == err)
{
return false;
}
#else
if (EAGAIN == err || EINTR == err)
{
return false;
}
#endif
THROW3 (IOException, "Can't accept socket", err);
}
client.attach(sock, true, true);
return true;
}
static void downheaph( MxHeap *h, int i )
{
int l = left(i);
int r = right(i);
MxHeapable *moving, *hl, *hr, *largest;
int oldpos, newpos;
MX_ASSERT( i >= 0 && i < lengthb( &(h->data) ) );
/* we are careful here to handle the case where l is in range, but r is not */
while( l < lengthb( &(h->data) ) )
{
moving = (MxHeapable *) getpb ( &(h->data), i );
hl = (MxHeapable *) getpb ( &(h->data), l );
hr = (MxHeapable *) getpb ( &(h->data), r );
if(
( r < lengthb( &(h->data) ) ) &&
( get_heap_key( hl ) < get_heap_key( hr ) )
)
largest = hr;
else
largest = hl;
if( get_heap_key( moving ) < get_heap_key( largest ) )
{
oldpos = get_heap_pos( moving );
newpos = get_heap_pos( largest );
swaph( h, oldpos, newpos );
i = newpos;
l = left( i );
r = right( i );
}
else
break;
}
}
/* remove a particular element of the heap */
void removeh( MxHeap *h, MxHeapable *t )
{
MxHeapable *temp;
int i, end;
if( !is_in_heap( t ) ) return;
i = get_heap_pos( t );
end = lengthb( &(h->data) ) - 1;
MX_ASSERT( i >= 0 && i <= end );
not_in_heap( t );
if( i!= end )
{
swaph( h, i, end );
chopb( &(h->data) );
temp = (MxHeapable *) getpb ( &(h->data), i );
if( get_heap_key( temp ) < get_heap_key( t ) )
downheaph( h, i );
else
upheaph( h, i );
}
else
chopb( &(h->data) ); /* remove last element */
}
int16_t MessageBuffer::getShort(void)
{
int16_t ret;
MX_ASSERT(readable() >= sizeof(int16_t));
getImpl(&ret, sizeof(int16_t));
return byteOrder_.toOrder(ret, ByteOrder::NATIVE_ORDER);
}
Logger::Logger(int level, const std::string& name, uint16_t bufferSize,
mxcore::SharedPtr<LoggerImpl> impl) :
level_(level), name_(name), buffer_(NULL), bufferSize_(bufferSize),
impl_(impl)
{
MX_ASSERT(bufferSize_ > 0);
buffer_ = new char[bufferSize_ + 1];
}
uint64_t MessageBuffer::getULong(void)
{
uint64_t ret;
MX_ASSERT(readable() >= sizeof(ret));
getImpl(&ret, sizeof(uint64_t));
return byteOrder_.toOrder(ret, ByteOrder::NATIVE_ORDER);
}
void swapb( Block *b, int i, int j)
{
char tempspace[12];
void *temp = tempspace;
void *place1 = (char *) b->data + (i * b->size_each);
void *place2 = (char *) b->data + (j * b->size_each);
if( b->size_each > 12 ) swapb_big( b, i, j, place1, place2 );
MX_ASSERT( i >= 0 && i < b->used );
MX_ASSERT( j >= 0 && j < b->used );
MX_COPY (place1, b->size_each, temp);
MX_COPY (place2, b->size_each, place1);
MX_COPY (temp, b->size_each, place2);
}
/* access in place without modifying heap.
* unused in the LOD module */
void *itemh( MxHeap *h, int i )
{
MxHeapable *temp;
MX_ASSERT( i >= 0 && i < lengthb( &(h->data) ) );
temp = (MxHeapable *) getpb( &(h->data), i );
return temp->payload;
}
void ServerSocket::attach(int handle, bool isBlocking)
{
MX_ASSERT(-1 != handle);
close();
handle_ = handle;
isBlocking_ = isBlocking;
}
void mxquadric3_init( MxQuadric3 *q, double a, double b, double c, double d, double area)
{
q->a2 = a*a; q->ab = a*b; q->ac = a*c; q->ad = a*d;
q->b2 = b*b; q->bc = b*c; q->bd = b*d;
q->c2 = c*c; q->cd = c*d;
q->d2 = d*d;
q->r = area;
MX_ASSERT(!( quad_evaluate( q, 0, 0, 0 ) < 0 ));
MX_ASSERT(!( quad_evaluate( q, 0, 0, 0 ) < 0 ));
/*
MX_ASSERT( ((*((int *)(&q->a2)) >> 23) & 0xFF) != 0xFF );
MX_ASSERT( ((*((int *)(&q->a2)) >> 23) & 0xFF) != 0xFF );
MX_ASSERT( !isNaN( q->a2 ) );
*/
} /* end function mxquadric3_init */
MxBool face_is_inorder( const MxFace *f, MxVertexID v0, MxVertexID v1 )
{
if( f->v[0]==v0 ) return f->v[1]==v1;
else if( f->v[1]==v0 ) return f->v[2]==v1;
else {
MX_ASSERT(f->v[2]==v0);
return f->v[0]==v1;
}
}
int face_find_vertex( const MxFace *f, MxVertexID i )
{
if( f->v[0]==i ) return 0;
else if( f->v[1]==i ) return 1;
else {
MX_ASSERT(f->v[2]==i);
return 2;
}
}
/* HELPER
* calculates the maximum from 3 doubles
*/
static double max3f( double f1, double f2, double f3 )
{
if( f1 >= f2 )
if( f1 >= f3 )
return f1;
else {
MX_ASSERT( f3 >= f2 );
return f3;
}
else
if( f2 >= f3 )
return f2;
else {
MX_ASSERT( f3 >= f1 );
return f3;
}
} /* end function max3f */
bool SyncEchoClient::sendAndRecv(const std::string& message)
throw (mxcore::IOException&)
{
MX_ASSERT(!message.empty());
std::string recvMsg;
socket_.writeN(message.c_str(), message.size());
bool ret = readN(socket_, recvMsg, (int) message.size());
return ret && (message == recvMsg);
}
MxVertexID face_opposite_vertex( const MxFace *f, MxVertexID v0, MxVertexID v1 )
{
if( f->v[0]!=v0 && f->v[0]!=v1 ) return f->v[0];
else if( f->v[1]!=v0 && f->v[1]!=v1 ) return f->v[1];
else {
MX_ASSERT( f->v[2]!=v0 && f->v[2]!=v1 );
return f->v[2];
}
}
void mxv_cross(double *r, const double *u, const double *v, int dim)
{
if( dim == 3 )
{
r[0] = (u[1] * v[2]) - (v[1] * u[2]);
r[1] = -(u[0] * v[2]) + (v[0] * u[2]);
r[2] = (u[0] * v[1]) - (v[0] * u[1]);
}
else MX_ASSERT(0);
}
void IOServiceLibEvent::send(const ChannelId& id,
mxcore::SharedPtr<mxcore::ByteBuffer> message, int timeout)
{
ChannelContext* ctx = findChannel(id);
MX_ASSERT(NULL != ctx);
MX_ASSERT(ctx->isConnector());
MX_ASSERT(message->remaining() > 0);
ConnectorChannelContext* connectorCtx = (ConnectorChannelContext*) ctx;
bool haveMessage = connectorCtx->haveMessageToWrite();
connectorCtx->putWriteMessage(ChannelMessage(message, timeout, false));
if (!haveMessage)
{
connectorCtx->registWrite();
connectorCtx->registWriteTimer(timeout);
}
}
