virtual void flush()
{
assert(fd >= 0);
#ifdef TCP_CORK
int flag = 0;
setsockopt(fd, IPPROTO_TCP, TCP_CORK, &flag , sizeof(flag));
flag = 1;
setsockopt(fd, IPPROTO_TCP, TCP_CORK, &flag , sizeof(flag));
#else
send(sendBuffer.get(), sendBuffer.size());
sendBuffer.clear();
#endif
}
void MeshCylinderRenderer::DrawCylinderBuffer(const ExpandableBuffer<GLfloat>& position, const ExpandableBuffer<GLfloat>& color, const ExpandableBuffer<GLfloat>& textureCoord1, const ExpandableBuffer<GLfloat>& textureCoord2)
{
// NOTE: leaked, but this is a singleton
if (m_Quadric == 0)
{
m_Quadric = gluNewQuadric();
}
if( m_Quadric == NULL )
{
fprintf( stderr, "quadric allocation is failed\n");
}
// we extract the centers and radii from the encoding that is usually passed to the CG program
const int numBalls = position.getNumObjects()/16;
for (int i=0; i<numBalls; i++)
{
// endpoints
const CCVOpenGLMath::Vector endpoint1(textureCoord1.get(i*16 + 0),
textureCoord1.get(i*16 + 1),
textureCoord1.get(i*16 + 2),
1);
const CCVOpenGLMath::Vector endpoint2(textureCoord2.get(i*16 + 0),
textureCoord2.get(i*16 + 1),
textureCoord2.get(i*16 + 2),
1);
// radius is stored as the Z of position
const GLfloat radius = position.get(i*16 + 2);
// extract color
glColor3f(color.get(i*16 + 0),
color.get(i*16 + 1),
color.get(i*16 + 2));
glPushMatrix();
// gluCylinder draws on the z axis.
// so we need to rotate cylinderUp to align with the z axis
const CCVOpenGLMath::Vector cylinderUp = (endpoint2 - endpoint1);
const GLfloat height = cylinderUp.norm();
// convert cylinderUp to spherical coordinates. OpenGL needs this in degrees.
const GLfloat RAD_TO_DEG = 180.0f/M_PI;
const GLfloat phi = acos(cylinderUp[2]/height) * RAD_TO_DEG;
const GLfloat theta = atan2(cylinderUp[1],cylinderUp[0]) * RAD_TO_DEG;
// prepare to draw
// (rotate phi down, remaining aligned with x-axis, then rotate theta)
glTranslatef(endpoint1[0], endpoint1[1], endpoint1[2]);
glRotatef(theta, 0, 0, 1);
glRotatef(phi, 0, 1, 0);
gluCylinder(m_Quadric,
radius, // GLdouble base,
radius, // GLdouble top,
height,
LEVEL_OF_DETAIL, // GLint slices,
1); // GLint stacks);
glPopMatrix();
}
}
virtual void write(const void *data, const size_t size)
{
assert(fd >= 0);
if (size == 0)
return;
#ifdef TCP_CORK
send(data, size);
#else
if (size >= SEND_BUFFER_SIZE_LIMIT)
{
flush();
send(data, size);
}
else
{
sendBuffer.add(data, size);
if (sendBuffer.size() >= SEND_BUFFER_SIZE_LIMIT)
flush();
}
#endif
}
void MeshHelixRenderer::DrawHelixBuffer(const ExpandableBuffer<GLfloat>& position, const ExpandableBuffer<GLfloat>& color, const ExpandableBuffer<GLfloat>& textureCoord1, const ExpandableBuffer<GLfloat>& textureCoord2)
{
// NOTE: leaked, but this is a singleton
if (m_Quadric == 0)
{
m_Quadric = gluNewQuadric();
}
// we extract the centers and radii from the encoding that is usually passed to the CG program
const int numBalls = position.getNumObjects()/16;
for (int i=0; i<numBalls; i++)
{
// endpoints
const CCVOpenGLMath::Vector endpoint1(textureCoord1.get(i*16 + 0),
textureCoord1.get(i*16 + 1),
textureCoord1.get(i*16 + 2),
1);
const CCVOpenGLMath::Vector endpoint2(textureCoord2.get(i*16 + 0),
textureCoord2.get(i*16 + 1),
textureCoord2.get(i*16 + 2),
1);
// radius is stored as the Z of position
const GLfloat radius = position.get(i*16 + 2);
// extract color
glColor3f(color.get(i*16 + 0),
color.get(i*16 + 1),
color.get(i*16 + 2));
glPushMatrix();
// gluHelix draws on the z axis.
// so we need to rotate helixUp to align with the z axis
const CCVOpenGLMath::Vector helixUp = (endpoint2 - endpoint1);
const GLfloat height = helixUp.norm();
// convert helixUp to spherical coordinates. OpenGL needs this in degrees.
const GLfloat RAD_TO_DEG = 180.0f/M_PI;
const GLfloat phi = acos(helixUp[2]/height);
const GLfloat theta = atan2(helixUp[1],helixUp[0]);
// prepare to draw
// (rotate phi down, remaining aligned with x-axis, then rotate theta)
glTranslatef(endpoint1[0], endpoint1[1], endpoint1[2]);
glRotatef(theta * RAD_TO_DEG, 0, 0, 1);
glRotatef(phi * RAD_TO_DEG, 0, 1, 0);
// construct a triangle strip helix
const GLfloat HEIGHT_TO_THETA = (1.0f / height) * 360.0f * HEIGHT_TO_COILS;
int nAngles = height / HEIGHT_STEP;
int nVertices = 2 * nAngles;
GLfloat vertices[nVertices][3];
GLfloat normals[nVertices][3];
GLfloat heightIter = 0;
for (int i = 0; i < nVertices; i+=2)
{
GLfloat thetaIter = heightIter * HEIGHT_TO_THETA;
normals[i+1][0] = normals[i][0] = cos(thetaIter);
normals[i+1][1] = normals[i][1] = sin(thetaIter);
normals[i+1][2] = normals[i][2] = 0;
vertices[i][0] = radius * cos(thetaIter);
vertices[i][1] = radius * sin(thetaIter);
vertices[i][2] = heightIter + STRIP_HEIGHT;
vertices[i+1][0] = radius * cos(thetaIter);
vertices[i+1][1] = radius * sin(thetaIter);
vertices[i+1][2] = heightIter;
heightIter += HEIGHT_STEP;
}
// render
glVertexPointer(3, GL_FLOAT, 0, vertices);
glNormalPointer(GL_FLOAT, 0, normals);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glDrawArrays(GL_TRIANGLE_STRIP, 0, nVertices);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glPopMatrix();
}
}