Sócrates emprega Pombos na caça ao voto...

Depois de votar na oposição, um ou dois pombos lançaram duas bombas sobre mim. Raio do Sócrates, até os pombos conseguiu comprar.

"We got the biggest puzzle a game’s ever had: you."

Olhando para trás, este tipo de post é completamente contrário aquilo que eu mais quero.




O Ken Levine diz melhor que eu:



Quem ver isso tudo tem aqui a parte 2 e parte 3.

Quote do post anterior: "Devido à conjectura, não me consigo imaginar a desenvolver jogos para qualquer tipo de lucro."

Fodasse para isso. Eu quero fazer merdas destas.

Neste post digo:

"Um gajo tá a estudar a vida toda e depois quando chega a altura do salto, há sempre decisões a tomar. Espero não me arrepender."

E arrependo-me de não ter procurado outros trabalhos como freelancer ou part time e querer logo ir morder a vaca gorda.

E agora penso no que hei de fazer à minha vida, quando estou inscrito à cadeira mais interessante que há naquela faculdade e colocada mesmo no meio dum dia de trabalho.

void extrudeSolidFromPolygon(GLfloat data[][2], unsigned int dataSize,
 GLdouble thickness, GLuint side, GLuint edge, GLuint whole)
{
 static GLUtriangulatorObj *tobj = NULL;
 GLdouble vertex[3], dx, dy, len;
 int i;
 int count = (int) (dataSize / (2 * sizeof(GLfloat)));

 if (tobj == NULL) {
   tobj = gluNewTess();  /* create and initialize a GLU
                            polygon tesselation object */
   gluTessCallback(tobj, GLU_BEGIN, glBegin);
   gluTessCallback(tobj, GLU_VERTEX, glVertex2fv);  /* semi-tricky

                                                     */
   gluTessCallback(tobj, GLU_END, glEnd);
 }
 glNewList(side, GL_COMPILE);
 glShadeModel(GL_SMOOTH);  /* smooth minimizes seeing
                              tessellation */
 gluBeginPolygon(tobj);
 for (i = 0; i < count; i++) {
   vertex[0] = data[i][0];
   vertex[1] = data[i][1];
   vertex[2] = 0;
   gluTessVertex(tobj, vertex, data[i]);
 }
 gluEndPolygon(tobj);
 glEndList();
 glNewList(edge, GL_COMPILE);
 glShadeModel(GL_FLAT);  /* flat shade keeps angular hands
                            from being * * "smoothed" */
 glBegin(GL_QUAD_STRIP);
 for (i = 0; i <= count; i++) {
   /* mod function handles closing the edge */
   glVertex3f(data[i % count][0], data[i % count][1], 0.0);
   glVertex3f(data[i % count][0], data[i % count][1], thickness);
   /* Calculate a unit normal by dividing by Euclidean
      distance. We * could be lazy and use
      glEnable(GL_NORMALIZE) so we could pass in * arbitrary
      normals for a very slight performance hit. */
   dx = data[(i + 1) % count][1] - data[i % count][1];
   dy = data[i % count][0] - data[(i + 1) % count][0];
   len = sqrt(dx * dx + dy * dy);
   glNormal3f(dx / len, dy / len, 0.0);
 }
 glEnd();
 glEndList();
 glNewList(whole, GL_COMPILE);
 glFrontFace(GL_CW);
 glCallList(edge);
 glNormal3f(0.0, 0.0, -1.0);  /* constant normal for side */
 glCallList(side);
 glPushMatrix();
 glTranslatef(0.0, 0.0, thickness);
 glFrontFace(GL_CCW);
 glNormal3f(0.0, 0.0, 1.0);  /* opposite normal for other side

                              */
 glCallList(side);
 glPopMatrix();
 glEndList();
}

E de não ter tempo para fazer isto.