Tópico: Inventar jogos eletrônicos é profissão promissora na Alemanha

[Adriano]

Na Escola Superior de Design de Mídia de Düsseldorf, é possível ganhar dinheiro jogando. Os estudantes de design de jogos eletrônicos podem contar com um emprego certo, pois o setor tende a se expandir.

Uma pequena nave espacial paira no infinito, atira nos inimigos e luta pelas matérias-primas espalhadas por planetas coloridos. Falko, de 27 anos, estudante de design de games, aperta o mouse e faz a nave se deslocar a atracar no próximo planeta. Ele inventou e programou esse jogo junto com outros estudantes e pretende exercer essa profissão no futuro.

"Eu tinha uma formação de informática e acabei descobrindo que preferia fazer algo criativo a consertar computadores", diz Falko. Então ele descobriu o curso de design de games na Escola Superior de Design de Mídia, em Düsseldorf, e se convenceu que seria uma boa idéia. Só faltava convencer os pais da sua opção, pois eles não tinham nenhuma imagem concreta do que poderia ser essa profissão.

Estudar ou jogar?

Sebastian, de 22 anos, um amigo de Falko na faculdade, também pode dizer o mesmo das primeiras reações de seus pais e avós à opção de ele se tornar spielemacher, ou "criador de jogos". Mas as coisas acabaram mudando e agora ele pode passar horas jogando e ainda dizer que está estudando.

O bacharelado em design de games em Düsseldorf existe desde 2006. É um dos poucos lugares que oferecem uma formação específica para programadores de jogos na Alemanha. Mas optar por essa profissão não sai barato, pois a mensalidade custa 799 euros. Experimentar novos jogos de computador faz parte do currículo, mas é evidente que ninguém sai desse curso com um diploma só porque sabe jogar.

Matemática e criatividade

Desde o Pacman, a linguagem dos jogos se desenvolveu com extrema rapidezBildunterschrift: Großansicht des Bildes mit der Bildunterschrift:  Desde o Pacman, a linguagem dos jogos se desenvolveu com extrema rapidezNas aulas de informática, os estudantes do primeiro semestre aprendem a programar. Depois é que passam a trabalhar com programas de design gráfico e animação. Disciplinas artísticas clássicas, como desenhar e modelar também fazem parte do currículo.

Num dos cursos, por exemplo, os estudantes aprendem a esboçar uma criatura fictícia para um jogo – primeiro no papel e depois como pequena escultura. O personagem de Falko pode ser apreciado numa das vitrines espalhadas pelos corredores da faculdade – um guerreiro de mais ou menos 30 centímetros que encara, com seus olhos castanhos, os passantes.

No início, os estudantes cumprem um currículo básico, comum a todos. Depois de quatro semestres, eles se especializam e optam entre fazer a concepção de jogos, criar mundos fantasiosos ou programar os jogos.

Boas chances de carreira

É praticamente certo que eles consigam um emprego depois da faculdade, garante a professora Linda Breitlauch. Embora os jogos eletrônicos ainda sejam considerados coisa de criança ou um fenômeno periférico e até perigoso, cada vez mais gente passa seu tempo em frente a um console. Na Alemanha, as empresas de criação de jogos eletrônicos se multiplicam.

O setor tem índices de crescimento de até 20%, informa Breitlauch: "Alguma hora não vai dar mais para ignorar isso". A criação de um jogo pode ser comparada a grandes produções de cinema, seja em termos financeiros, temporais ou pessoais. O processo pode durar até três anos.

Estigma ainda pesa

Embora a Alemanha ainda esteja bem aquém do estágio do setor de jogos nos EUA ou em certos países asiáticos, há projetos isolados – como o jogo estratégico Settlers ou o complexo jogo de ação Crisis – que conseguiram um alcance internacional. Mesmo assim, os jogos eletrônicos ainda não se livraram da imagem negativa que têm na Alemanha. Isso é o que sentem os estudantes. Sobretudo jogos de combate e violência são alvo de críticas.

Sebastian acha fantástica a recriação de mundos diversos nos jogos: "Há muita coisa fascinante num jogo. Pode ser um personagem ou o enredo, mas às vezes basta uma imagem para prender a atenção da pessoa". E essa fascinação ele pretende propagar algum dia com o seu próprio jogo eletrônico comercial.
 

Leila Knüppel (sm)

http://www.dw-world.de/dw/article/0,2144,3204789,00.html

[gogorongon]

Jogar um jogo para procurar bugs ou para analisar como foi feito é muito diferente de jogar apenas para se divertir, e até hoje os jornalistas continuam com essa visão estereotipada de que jogos são feitos brincando.

Me pergunto se continuariam escrevendo desse jeito se tivessem que aprender a fazer algo centenas de vezes maior que isso (o que é normal hoje em dia):

Código: [Selecionar]

float r_z_update_time = 0.0f;
#define Z_UPDATE_INTERVAL 0.1f
#define Z_UPDATE_SIZE  64

// software z buffer
float zBuf[Z_UPDATE_SIZE * Z_UPDATE_SIZE];


/*
==================
R_ProjectPoint

project a point from world co-ordinates to screen coordinates
==================
*/
void R_ProjectPoint (vec3_t vin, vec3_t vout)
{
 float fvin[4] = {vin[0], vin[1], vin[2], 1};
 float fvout[4];
 float *mm = r_world_matrix;
 float *mp = r_world_project;

 // transform our points - fvin will hold the final transformation
 fvout[0] = mm[0x0] * fvin[0] + mm[0x4] * fvin[1] + mm[0x8] * fvin[2] + mm[0xc] * fvin[3];
 fvout[1] = mm[0x1] * fvin[0] + mm[0x5] * fvin[1] + mm[0x9] * fvin[2] + mm[0xd] * fvin[3];
 fvout[2] = mm[0x2] * fvin[0] + mm[0x6] * fvin[1] + mm[0xa] * fvin[2] + mm[0xe] * fvin[3];
 fvout[3] = mm[0x3] * fvin[0] + mm[0x7] * fvin[1] + mm[0xb] * fvin[2] + mm[0xf] * fvin[3];

 fvin[0] = mp[0x0] * fvout[0] + mp[0x4] * fvout[1] + mp[0x8] * fvout[2] + mp[0xc] * fvout[3];
 fvin[1] = mp[0x1] * fvout[0] + mp[0x5] * fvout[1] + mp[0x9] * fvout[2] + mp[0xd] * fvout[3];
 fvin[2] = mp[0x2] * fvout[0] + mp[0x6] * fvout[1] + mp[0xa] * fvout[2] + mp[0xe] * fvout[3];
 fvin[3] = mp[0x3] * fvout[0] + mp[0x7] * fvout[1] + mp[0xb] * fvout[2] + mp[0xf] * fvout[3];

 // prevent division by 0
 if (fvin[3] == 0.0) fvin[3] = 0.000001;

 // normalize
 fvin[0] /= fvin[3];
 fvin[1] /= fvin[3];
 fvin[2] /= fvin[3];

 // map x and y to range 0..1, then scale to buffer dimensions
 vout[0] = (fvin[0] * 0.5 + 0.5) * Z_UPDATE_SIZE;
 vout[1] = (fvin[1] * 0.5 + 0.5) * Z_UPDATE_SIZE;

 // scale to the depth range we're using
 vout[2] = (fvin[2] * 0.25 + 0.75);

 // move points outside the image into the image
 if (vout[0] < 0) vout[0] = 0;
 if (vout[0] >= Z_UPDATE_SIZE) vout[0] = Z_UPDATE_SIZE - 1;
 if (vout[1] < 0) vout[1] = 0;
 if (vout[1] >= Z_UPDATE_SIZE) vout[1] = Z_UPDATE_SIZE - 1;
}


/*
==================
R_ProjectBBox

project a bounding box from world coordinates to screen coordinates, then take a 2D
"bounding box of the bounding box" for use in the occlusion culling tests
==================
*/
void R_ProjectBBox (float *mins, float *maxs, float *minsout, float *maxsout)
{
 int i;

 // initial corner points
 minsout[0] = minsout[1] = minsout[2] = 999999999;
 maxsout[0] = maxsout[1] = maxsout[2] = -999999999;

 for (i = 0; i < 8; i++)
 {
  vec3_t bboxptin;
  vec3_t bboxptout;

  // get the correct corner to use
  bboxptin[0] = (i & 1) ? mins[0] : maxs[0];
  bboxptin[1] = (i & 2) ? mins[1] : maxs[1];
  bboxptin[2] = (i & 4) ? mins[2] : maxs[2];

  // project to screen
  R_ProjectPoint (bboxptin, bboxptout);

  // store min and max
  if (bboxptout[0] < minsout[0]) minsout[0] = bboxptout[0];
  if (bboxptout[1] < minsout[1]) minsout[1] = bboxptout[1];
  if (bboxptout[2] < minsout[2]) minsout[2] = bboxptout[2];
  if (bboxptout[0] > maxsout[0]) maxsout[0] = bboxptout[0];
  if (bboxptout[1] > maxsout[1]) maxsout[1] = bboxptout[1];
  if (bboxptout[2] > maxsout[2]) maxsout[2] = bboxptout[2];
 }
}


int R_BoxInFrustum (vec3_t mins, vec3_t maxs);


void R_RunOccludeEntityTest (entity_t *ent, vec3_t mins, vec3_t maxs)
{
 vec3_t screen_mins, screen_maxs;
 int x;
 int y;

 R_ProjectBBox (mins, maxs, screen_mins, screen_maxs);

 for (y = screen_mins[1]; y <= screen_maxs[1]; y++)
 {
  int p = y * Z_UPDATE_SIZE;

  for (x = screen_mins[0]; x <= screen_maxs[0]; x++)
  {
   if (zBuf[p + x] > screen_mins[2])
   {
    // not occluded
    ent->occluded = false;
    return;
   }
  }
 }

 // occluded
 ent->occluded = true;
}


void R_RunOcclusionTest (void)
{
 int i;
 entity_t *ent;
 vec3_t mins, maxs;

 if (!r_worldentity.model || !cl.worldmodel) return;

 for (i = 0; i < cl_numvisedicts; i++)
 {
  ent = cl_visedicts[i];

  // not occluded
  ent->occluded = false;

  switch (ent->model->type)
  {
  case mod_brush:
  case mod_alias:
  case mod_sprite:
   // get entity origin
   VectorAdd (ent->origin, ent->model->mins, mins);
   VectorAdd (ent->origin, ent->model->maxs, maxs);

   // do the bbox cull here
   if (R_BoxInFrustum (mins, maxs) == FRUSTUM_OUTSIDE)
   {
    // occluded
    ent->occluded = true;
   }
   else
   {
    // test for regular occlusion
    R_RunOccludeEntityTest (ent, mins, maxs);
   }

   break;

  default:
   break;
  }
 }
}


void R_CaptureDepth (void)
{
 texture_t *t;
 extern texture_t *texturelist;
 extern float r_farclip;

 // accumulate update time always
 r_z_update_time += r_frametime;

 // don't update if it's not time to do so yet
 if (r_z_update_time < Z_UPDATE_INTERVAL && r_framecount > 5) return;

 // begin the timer again
 r_z_update_time = 0;

 // render at Z_UPDATE_SIZE x Z_UPDATE_SIZE in the bottom-right corner
 // create the viewport for the capture
 R_SetupGLViewport (vid.glwidth - (Z_UPDATE_SIZE * 2), Z_UPDATE_SIZE, Z_UPDATE_SIZE, Z_UPDATE_SIZE, r_refdef.fov_y, 4, r_farclip);

 // store modelview and projection matrixes for reuse
 // fixme - do this in software to prevent a sync-wait
 glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix);
 glGetFloatv (GL_PROJECTION_MATRIX, r_world_project);

 // set up the depth range for the capture
 // we can use a good chunk of the depth buffer here
 glDepthFunc (GL_LEQUAL);
 glDepthRange (0.5f, 1.0f);
 glDepthMask (GL_TRUE);

 // shut down everything we don't need for this
 glDisable (GL_TEXTURE_2D);
 glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

 // base vertex arrays
 vaEnableVertexArray (3);

 for (t = texturelist; t; t = t->texturelist)
 {
  // get the texture chain
  msurface_t *surf = t->texturechain;

  // no surfs in use
  if (!surf) continue;

  // skip over these surf types (fixme - this is ugly)
  if (surf->flags & SURF_DRAWTURB)
  {
   if (surf->flags & SURF_DRAWOPAQUE)
   {
   }
   else continue;
  }

  if (surf->flags & SURF_DRAWSKY) continue;

  // walk the chain
  for (; surf; surf = surf->texturechain)
  {
   glpoly_t *p;

   // draw polys here as we're sending some liquids through it too
   for (p = surf->polys; p; p = p->next)
   {
    int i;
    glvertex_t *v;

    vaBegin (GL_TRIANGLE_FAN);

    for (i = 0, v = p->verts; i < p->numverts; i++, v++)
     vaVertex3fv (v->tv);

    vaEnd ();
   }
  }
 }

 // done with the render
 vaDisableArrays ();

 // capture the depth buffer
 // per the spec, this scales to a 0..1 range, irrespective of the actual depth range
 // (http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/readpixels.html)
 // but this is a lie...
 glReadPixels (vid.glwidth - (Z_UPDATE_SIZE * 2), Z_UPDATE_SIZE, Z_UPDATE_SIZE, Z_UPDATE_SIZE, GL_DEPTH_COMPONENT, GL_FLOAT, zBuf);

 // bring stuff back up
 glEnable (GL_TEXTURE_2D);
 glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

 // glColorMask leaves the current colour state undefined
 glColor3f (1, 1, 1);
}

[Adriano]

O principal dessa área é o pensamento criativo. Tem uma produtora que alocava seus profissionais num castelo, e sem horários, eles preferiam a noite, onde produziram grandes jogos. Não me lembro qual empresa, mas é bem conhecida.

[Nightstalker]

Kasimier

Nesse exemplo que você deu, qual linguagem foi utilizada? Java?

[gogorongon]

Eu diria que o principal em qualquer profissão é ter paixão pelo que se faz. Isso só não é muito aparente em algumas profissões porque a quantidade de pessoas que trabalha sem se importar com o que faz é muito grande.

Criatividade é conseqüência de prestar atenção e se esforçar naquilo que se gosta. Não de forma centralizada, mas também aplicando conhecimentos e experiências oriundas de outras áreas.

Kasimier

Nesse exemplo que você deu, qual linguagem foi utilizada? Java?

C. Em Java o código ficaria bem maior.