"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.