DeviantArt

PORTUGUÊS

Arte-presente que fiz para o   stefanfurshephsky

Bem, vejo bastando o pessoal criando conteúdo retro para jogos, mas são mó poucos que fazem para a plataforma mobile rs
Antigamente, muitos celulares vinham equipados com a plataforma J2ME, alguns que tinham os processadores da Qualcomm ainda tinham o BREW, que também dava suporte ao Java, e outros com o Symbian, que mais tarde traria a plataforma Flash Lite.
Mas como o Java era o que mais frequentemente vinha acompanhado com esses celulares, muitos desenvolvedores escolhiam desenvolver seus jogos nessa plataforma.
E os celulares eram SUPER-LIMITADOS, são inúmeras as limitações que esses celulares tinham. Mas embora tanta limitações, era possível criar jogos 3D neles.
A plataforma J2ME tinha um pacote opcional, isso é, os fabricantes escolhiam se adicionavam ou não em seus celulares, que era o M3G (Mobile 3D Graphics), que fazia com que esses celulares rederizassem gráficos 3D a partir do OpenGL ES 1.1.
Na época, era raríssimo algum celular que tivesse um chip de aceleração gráfica, então, muitas vezes esses gráficos eram renderizados pela CPU do celular, a partir de uma renderização por Software.

Por ser um pacote opcional, alguns celulares não vinham com esse pacote e por isso não eram compatíveis com jogos 3D, o que levava os desenvolvedores a criarem sua própria API de renderização 3D, como é o caso do Doom RPG, Left 2 Die e entre outros. Todos eles funcionavam muito diferente do M3G, então nesse caso, quis simular os celulares que vinham com esse pacote no Blender.
Como esses celulares vinham com processadores muito fracos, e muito raramente vinham com GPU, não era de se esperar uma boa performance, fui bem bonzinho fazendo essas animações com 5 FPS rsrsrs

São essas algumas descrições das limitações desses aparelhos:

*Você tinha um limite de tamanho por aplicativo, alguns celulares só permitiam a instalação de aplicativos que vinham com menos de 300kb, 500kb, 2mb e por ai vai. Por isso, os desenvolvedores tinham que diminuir o tamanho o máximo o possível de seus jogos, e para isso eles faziam alguns truques, que era de indexar as cores das texturas, desenhá-las com a menor resolução possível e fazer o mapeamento de todo o mapa com o menor número de texturas o possível, muitas vezes, com apenas uma imagem
*Os celulares tinham uma limitação bem comprimida de número de cores, mas variavam bastante, na maioria das vezes, as telas limitavam de 4 mil cores até 20 mil.
*A API padrão do Java não permitia você alterar o tamanho de uma textura e nem mesmo rotacionar-las, a não ser que você mesmo programasse, o que pesava muito na memória RAM, então os desenvolvedores muitas vezes separavam os sprites em diferentes imagens, com diferentes tamanhos, para fazer o redimensionamento
*A memória RAM era extremamente baixa, e variavam de 200kb até 20mb, e na época, você não tinha como ver essa especificação em nenhum lugar, se você conseguia um celular com pelo menos 3mb de RAM, você era um sortudo. Os desenvolvedores sofriam com os java.lang.outofmemoryerror
*Os gráficos 3D não suportavam sombras, alguns desenvolvedores colocavam um PNG para simular uma sombra, porém, texturas transparentes pesavam muito, o que fazia mutias vezes eles preferirem nem colocar qualquer textura com canal transparente
*Para economizar tempo de renderização, o M3G tentava renderizar o mínimo o possível, buscando renderizar apenas o objeto que estava a frente, por causa disso, dependendo da forma que você programava como os objetos seriam renderizados, as vezes eles saiam bugados, se por exemplo você colocasse uma cerca que na verdade seria um plano com uma textura transparente, ele poderia acabar não renderizando atrás
*Malhas pesavam bastante, então você tinha que fazer seus personagens e mapas com o menor número de triângulos possíveis
*Por causa disso, os gráficos eram pior do que um PlayStation 1 xD

Essas são algumas das limitações que você tinha na época. Era muito difícil criar, encontrar ou mesmo rodar um jogo 3D, por isso a maioria dos jogos eram em 2D, o que ainda assim tinham muitos problemas de performance e compatibilidade jasjasjasj

Pretendo fazer para mais alguns amigos meus em breve hehehe :3

#J2MEterno

ENGLISH

Gift-art i made to   stefanfurshephsky

Well, I see so many people creating retro content for games, but there are only a few who do it for the mobile platform
In the past, many cell phones came equipped with the J2ME platform, some that had Qualcomm processors had BREW, which also supported Java, and others with Symbian, which would later bring the Flash Lite platform.
But since Java was the one that most often came with these phones, many developers chose to develop their games on that platform.
And cell phones were SUPER-LIMITED, there are countless limitations that these cell phones had. But despite so many limitations, it was possible to create 3D games on them.
The J2ME platform had an optional package, wich means manufacturers chose whether or not to add them to their cell phones, which was the M3G (Mobile 3D Graphics), which made these phones able to rederize 3D graphics with OpenGL ES 1.1.
At the time, it was very rare for any cell phone to have a graphics acceleration chip, so many times these graphics were rendered by the cell phone's CPU, from software rendering.

As an optional package, some phones did not come with this package and therefore were not compatible with 3D games, which led developers to create their own 3D rendering API, as is the case with Doom RPG, Left 2 Die and among others. They all worked very differently from the M3G, so in this case, I wanted to simulate the phones that came with this package in Blender.
As these phones came with very weak processors, and very rarely came with GPU, it was not expected a good performance, I was very nice doing these animations with 5 FPS lol

These are some descriptions of the limitations of these devices:

*You had a size limit per application, some phones only allowed the installation of applications that came with less than 300kb, 500kb, 2mb and so on. For this reason, the developers had to reduce the size of their games as much as possible, and for that they did some tricks, which was to index the colors of the textures, draw them with the lowest possible resolution and map the entire map with as few textures as possible, often with just one image
*Cell phones had a very limited number of colors, but they varied a lot, most of the time, screens were limited from 4 thousand colors to 20 thousand.
*The standard Java API didn’t allow you to change the size of a texture or even rotate it, unless you program it yourself, which weighed heavily in RAM, so developers often split sprites into different images, with different sizes, to resize
*The RAM was extremely low, and ranged from 200kb to 20mb, and at the time, you had no way of seeing this specification anywhere, if you could get a cell phone with at least 3mb of RAM, you were lucky. Developers suffered alot from java.lang.outofmemoryerror
*3D graphics did not supported shadows, some developers put a PNG to simulate a shadow, however, transparent textures weighed a lot, which made them often prefer not to even put any texture with transparent channel
*To save rendering time, M3G tries to render as little as possible, trying to render only the object that was in front, because of that, depending on the way you programmed how the objects would be rendered, sometimes they come out buggy, as an example, if you put a fence that would actually be a plane with a transparent texture, it could end up not rendering behind
*Meshes weighed a lot, so you had to make your characters and maps with the fewest possible triangles
*Because of that, the graphics were worse than a PlayStation 1 xD

These are some of the limitations that you had at that time. It was very difficult to create, find or even run a 3D game, so most games were in 2D, which still had a lot of performance and compatibility issues lmao

I wanna make more for more friends soon :3

#J2MEternal