TCPConnection::TCPConnection(unsigned short port) {
checkInitialized();
// create socket for incoming connections
int servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
assert(servSock >= 0, "Failed to create socket\n");
// construct local address
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(port);
// bind to the local address
int result = bind(servSock, (struct sockaddr *)&servAddr, sizeof(servAddr));
assert(result >= 0, "Failed to bind to port\n");
// mark the socket to listen
result = listen(servSock, 1);
assert(result >= 0, "Failed to listen\n");
struct sockaddr_in clntAddr;
#ifdef WIN32
int clntLen = sizeof(clntAddr);
#else
socklen_t clntLen = sizeof(clntAddr);
#endif
int clntSock = accept(servSock, (struct sockaddr *)&clntAddr, &clntLen);
assert(clntSock >= 0, "Failed to accept\n");
fd = clntSock;
}
void ICanvas::setShadow(const Color& color,
float blur,
float offsetX,
float offsetY) {
checkInitialized();
_setShadow(color, blur, offsetX, offsetY);
}
int UDPServer::recv(char *buffer, int maxlen, Address *address, int timeout) {
checkInitialized();
if (!isReadable(sock, timeout)) { return 0; }
struct sockaddr_in sender;
#ifdef WIN32
int len = sizeof(sender);
#else
socklen_t len = sizeof(sender);
#endif
int received = ::recvfrom(sock, buffer, maxlen, 0,
(struct sockaddr *)&sender, &len);
//assert(received >= 0, "recv failed\n");
if (received < 0) {
return received;
}
// return the address of the sender
if (address) { *address = Address(sender); }
return received;
}
void ICanvas::setLineDash(float lengths[],
int count,
int phase) {
checkInitialized();
_setLineDash(lengths,
count,
phase);
}
void ICanvas::fillAndStrokeRoundedRectangle(float left, float top,
float width, float height,
float radius) {
checkInitialized();
_fillAndStrokeRoundedRectangle(left, top,
width, height,
radius);
}
bool TCPConnection::send(const char *buffer, int len) {
checkInitialized();
int sentBytes = ::send(fd, buffer, len, 0);
/*
assert(sentBytes >= 0, "send failed\n");
assert(sentBytes == len, "send sent a different number of bytes than expected\n");
*/
if(sentBytes != len) return false;
return true;
}
void send(Address address, const char *buffer, int len) {
checkInitialized();
// create a socket
int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
assert(sock >= 0, "Failed to create socket\n");
int sent = sendto(sock, buffer, len, 0, (struct sockaddr *)(&(address.addr)), sizeof(address.addr));
assert(sent >= 0, "send failed\n");
assert(sent == len, "send sent a different number of bytes than expected\n");
close(sock);
}
TCPConnection::TCPConnection(Address address) {
checkInitialized();
// create a socket
int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
assert(sock >= 0, "Failed to create socket\n");
// connect
int result = connect(sock, (struct sockaddr *)&address.addr, sizeof(address.addr));
assert(result >= 0, "Failed to connect\n");
fd = sock;
}
bool TCPConnection::recv(char *buffer, int len) {
checkInitialized();
int recvBytes = 0;
while (recvBytes < len) {
int received = ::recv(fd, buffer + recvBytes, len - recvBytes, 0);
//assert(received > 0, "recv failed\n");
if(received <= 0)
return false;
recvBytes += received;
}
return true;
}
void ICanvas::drawImage(const IImage* image,
float srcLeft, float srcTop, float srcWidth, float srcHeight,
float destLeft, float destTop, float destWidth, float destHeight) {
checkInitialized();
if (!RectangleF::fullContains(0, 0, image->getWidth(), image->getHeight(),
srcLeft, srcTop, srcWidth, srcHeight)) {
ILogger::instance()->logError("Invalid source rectangle in drawImage");
}
_drawImage(image,
srcLeft, srcTop, srcWidth, srcHeight,
destLeft, destTop, destWidth, destHeight);
}
UDPServer::UDPServer(unsigned short port) {
checkInitialized();
sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
assert(sock >= 0, "Failed to create socket\n");
// construct local address
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(port);
// bind to the local address
int result = bind(sock, (struct sockaddr *)&servAddr, sizeof(servAddr));
assert(result >= 0, "Failed to bind to port\n");
}
Address::Address(string hostname_, unsigned short port_) {
hostname = string(hostname_);
port = port_;
checkInitialized();
struct hostent *host;
unsigned int ip = 0;
if ((host = gethostbyname(hostname.c_str())) != NULL) {
memcpy(&ip, host->h_addr, host->h_length);
} else {
ip = inet_addr(hostname.c_str());
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = ip;
addr.sin_port = htons(port);
}
TCPConnection *TCPServer::listen(int timeout) {
checkInitialized();
if (!isReadable(sock, timeout)) return NULL;
// accept a connection
struct sockaddr_in clntAddr;
#ifdef WIN32
int clntLen = sizeof(clntAddr);
#else
socklen_t clntLen = sizeof(clntAddr);
#endif
int clntSock = accept(sock, (struct sockaddr *)&clntAddr, &clntLen);
assert(clntSock >= 0, "Failed to accept\n");
TCPConnection *conn = new TCPConnection();
conn->fd = clntSock;
return conn;
}
TCPServer::TCPServer(unsigned short port) {
checkInitialized();
// create socket for incoming connections
sock = (int)socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
assert(sock >= 0, "Failed to create socket\n");
// construct local address
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(port);
// bind to the local address
int result = bind(sock, (struct sockaddr *)&servAddr, sizeof(servAddr));
assert(result >= 0, "Failed to bind to port\n");
// mark the socket to listen (max 5 incoming connections)
result = ::listen(sock, 5);
assert(result >= 0, "Failed to listen\n");
}
void ICanvas::setLineJoin(StrokeJoin join) {
checkInitialized();
_setLineJoin(join);
}
void ICanvas::setLineCap(StrokeCap cap) {
checkInitialized();
_setLineCap(cap);
}
void ICanvas::setLineWidth(float width) {
checkInitialized();
_setLineWidth(width);
}
void ICanvas::setLineColor(const Color& color) {
checkInitialized();
_setLineColor(color);
}
void ICanvas::lineTo(float x, float y) {
checkInitialized();
_lineTo(x, y);
}
void ICanvas::moveTo(float x, float y) {
checkInitialized();
_moveTo(x, y);
}
void ICanvas::fill() {
checkInitialized();
_fill();
}
void ICanvas::fillRectangle(float left, float top,
float width, float height) {
checkInitialized();
_fillRectangle(left, top,
width, height);
}
void ICanvas::drawImage(const IImage* image,
float destLeft, float destTop, float destWidth, float destHeight) {
checkInitialized();
_drawImage(image, destLeft, destTop, destWidth, destHeight);
}
void ICanvas::setLineMiterLimit(float limit) {
checkInitialized();
_setLineMiterLimit(limit);
}
void ICanvas::beginPath() {
checkInitialized();
_beginPath();
}
void ICanvas::fillAndStroke() {
checkInitialized();
_fillAndStroke();
}
void ICanvas::removeShadow() {
checkInitialized();
_removeShadow();
}
void ICanvas::closePath() {
checkInitialized();
_closePath();
}
void btSoftBodySolverOutputCLtoGL::copySoftBodyToVertexBuffer( const btSoftBody * const softBody, btVertexBufferDescriptor *vertexBuffer )
{
btSoftBodySolver *solver = softBody->getSoftBodySolver();
btAssert( solver->getSolverType() == btSoftBodySolver::CL_SOLVER || solver->getSolverType() == btSoftBodySolver::CL_SIMD_SOLVER );
btOpenCLSoftBodySolver *dxSolver = static_cast< btOpenCLSoftBodySolver * >( solver );
checkInitialized();
btOpenCLAcceleratedSoftBodyInterface* currentCloth = dxSolver->findSoftBodyInterface( softBody );
btSoftBodyVertexDataOpenCL &vertexData( dxSolver->m_vertexData );
const int firstVertex = currentCloth->getFirstVertex();
const int lastVertex = firstVertex + currentCloth->getNumVertices();
if( vertexBuffer->getBufferType() == btVertexBufferDescriptor::OPENGL_BUFFER ) {
const btOpenGLInteropVertexBufferDescriptor *openGLVertexBuffer = static_cast< btOpenGLInteropVertexBufferDescriptor* >(vertexBuffer);
cl_int ciErrNum = CL_SUCCESS;
cl_mem clBuffer = openGLVertexBuffer->getBuffer();
cl_kernel outputKernel = outputToVertexArrayWithNormalsKernel;
if( !vertexBuffer->hasNormals() )
outputKernel = outputToVertexArrayWithoutNormalsKernel;
ciErrNum = clEnqueueAcquireGLObjects(m_cqCommandQue, 1, &clBuffer, 0, 0, NULL);
if( ciErrNum != CL_SUCCESS )
{
btAssert( 0 && "clEnqueueAcquireGLObjects(copySoftBodyToVertexBuffer)");
}
int numVertices = currentCloth->getNumVertices();
ciErrNum = clSetKernelArg(outputKernel, 0, sizeof(int), &firstVertex );
ciErrNum = clSetKernelArg(outputKernel, 1, sizeof(int), &numVertices );
ciErrNum = clSetKernelArg(outputKernel, 2, sizeof(cl_mem), (void*)&clBuffer );
if( vertexBuffer->hasVertexPositions() )
{
int vertexOffset = vertexBuffer->getVertexOffset();
int vertexStride = vertexBuffer->getVertexStride();
ciErrNum = clSetKernelArg(outputKernel, 3, sizeof(int), &vertexOffset );
ciErrNum = clSetKernelArg(outputKernel, 4, sizeof(int), &vertexStride );
ciErrNum = clSetKernelArg(outputKernel, 5, sizeof(cl_mem), (void*)&vertexData.m_clVertexPosition.m_buffer );
}
if( vertexBuffer->hasNormals() )
{
int normalOffset = vertexBuffer->getNormalOffset();
int normalStride = vertexBuffer->getNormalStride();
ciErrNum = clSetKernelArg(outputKernel, 6, sizeof(int), &normalOffset );
ciErrNum = clSetKernelArg(outputKernel, 7, sizeof(int), &normalStride );
ciErrNum = clSetKernelArg(outputKernel, 8, sizeof(cl_mem), (void*)&vertexData.m_clVertexNormal.m_buffer );
}
size_t numWorkItems = workGroupSize*((vertexData.getNumVertices() + (workGroupSize-1)) / workGroupSize);
ciErrNum = clEnqueueNDRangeKernel(m_cqCommandQue, outputKernel, 1, NULL, &numWorkItems, &workGroupSize,0 ,0 ,0);
if( ciErrNum != CL_SUCCESS )
{
btAssert( 0 && "enqueueNDRangeKernel(copySoftBodyToVertexBuffer)");
}
ciErrNum = clEnqueueReleaseGLObjects(m_cqCommandQue, 1, &clBuffer, 0, 0, 0);
if( ciErrNum != CL_SUCCESS )
{
btAssert( 0 && "clEnqueueReleaseGLObjects(copySoftBodyToVertexBuffer)");
}
} else {
btAssert( "Undefined output for this solver output" == false );
}
// clFinish in here may not be the best thing. It's possible that we should have a waitForFrameComplete function.
clFinish(m_cqCommandQue);
} // btSoftBodySolverOutputCLtoGL::outputToVertexBuffers
void ICanvas::stroke() {
checkInitialized();
_stroke();
}
