TIGSource Forums

Ok guys, since I love to do pixel art and It's a pain in the ass and since I also love Blender, Flash and Ilustrator, and I recentelly I started studying openGL (to see If I could do a moving cube).
Ok, enough intro. I was in this situation but then I got one idea:
What if there's a tool that allow the following process:

1) First, you make a 2D model using triangles, sort of modeling only in Front View Ortho in Blender/3DMax in Wireframe view.
2) After you created the 2D model ("3D" mesh), you can rig it (peg or pivot it) and create bones behaviour like in Toom Boom or Flash CS6.
3) Obviusly, you can color it by modifying Each Face Material, like in Blender and typical 3D tech, BUT you can also modify each edge to be visible or not and have a "weight" property, like some ilustration software (Sai or Manga Studio); that way we can have nice 2D ilustrations, sort of a mix between Inkscape/Ilustrator and Blender/3Dmax.
4) Stuff like Eyes can be made as textures, but for making pixel art (See Step 7), I dunno if it's posible to make them as Vectors Ilustrations.
6) After you made a nice 2D still Frame, you can then edit an animation Frame by Frame like a 2D animation software (Toom Boom/Flash/Anime Studio); BUT! here's the twist: Each frame Mesh can be independant of the others frames/Meshes.
7) Finally you have one big grid (based on user preferences) which check the 3D ("2D") scene and uses it as guide to start doing pixel art on his own using Derek Yu tutorial (Outline using the Edges labeled as "Outline" and filling colors using faces material, maybe some smoothing between two colors) This step is the reason why I think a vector special texture would be better than a raster one.

I think you can go beyond there and import the mesh directelly on your game, not even converting it to .PNG


So, What do you think?

The last step will be most of the work -- you're talking about an AI substitute which makes the decisions a pixel artist normally would, and it seems a bit far-fetched.  It'd be neat to see the results, but I doubt they'd be significantly different from simply shrinking a screenshot of the vector art and quantizing its colors.


Food for thought:

- What if the eye illustrations are too small to be easily represented given the available pixel count?  Will you expand them automatically, notify the user, or try to rearrange the colors?  How will you detect problem situations like this?

- How will you deal with overlapping portions of a character and situations where the pixel count causes two body parts not to have a gap in between?

- What kind of decision process will occur when quantization necessitates a change to body proportions -- will that arm be two pixels wide or three?


My advice is to delegate as many of the hard calls as possible to the user.  You'd do well to research computer text rendering, since it deals with similar inputs and outputs and is surprisingly complex.  Modern font formats require a great deal of "hinting" from designers to render text legibly at small sizes.

I'm not sure why if you spent all that time with the vector art that you would want to convert it to pixel art?  Why not just render it out as a mesh, sort of a flat 3d object?  You can render out quadratic bezier curves quite efficiently on a GPU, coupled with some 4x or higher AA and it'd look very slick.

Dude, that's one of the possible meanings of "vector graphics". With or without the curves.

But making it look nice will be very hard especially for small sprites as mr. Balster pointed out - you'll need all sorts of sub-pixel work and possibly some dithering if you want it to look clean, like the hand-made stuff..

I don't think an AI would be needed, here's a drawing to ilustrate the point:
(http://fc09.deviantart.net/fs70/f/2012/331/b/e/idea_for_a_3d_pixel_art_renderer_by_cristianceron-d5mc95a.png)
I don't know if what you sugested is the same as my idea though.
Sorry about the drawing, but only the lineart (light green) should had been Brown in the pixel art, is a mistake I didn't realize when drawing.

For the other points:
1) My idea is for HD sprites (+200px), for low res sprites, I guess it's best to do them manually, there's no point on automate all that.

2) One idea for that is stated in the drawing, but now I have another:
What if we have five special points on each grid "pixel"?, one in the center and four edges:
+---+
--+--
+---+
If one point is "diferent" than the others it will only matter if the center point is also touched by the same "diference".
In that case, this square will be divided into four smaller "pixels". Like this:
+---
++--
+++-
Or
@@--
@@--
++**
++**

3) The Software will be a Frame by Frame 2D Animation Editor, each Frame will have to be designed aestetically beautifuly by the artist.

I once saw a voxel renderer on youtube, maybe this is similar to those? (don't know).

Because there's no automated way to do HD pixel art.
Also, as KOF XIII proves it, It can be as valid as 3D.
2D animation is completely diferent than 3D animation, the same diference between a painting and a sculpture, GIMP vs Blender, etc.

And yes, if you want to code it, yes, you can render as traditional 3D, having the advantage that each frame will look good and will have the edges in a correct way, something extremelly hard to emulate in 3D (a 2D drawing).
And yes, if you do this, we could finally have real time pixel art, with lights effects and the sort.

Vector graphics usually is a series of filled 2d line segments, which is not the same as a 3d mesh (even a flat one with orthogonal projection).  I've written 'triangulation' code before (converting in my case true type font outlines to triangles suitable for rendering with D3D, OpenGL, ect...), so I do understand what the words mean and/or imply.

That said if I spent the time making a really nice vector art image it seems to me that it'd be a waste to convert it into a bitmap on todays systems.  Storing the image as a mesh of triangles is far more compact than a bitmap (short of the bitmap being miniscule).  Its resolution independent, and be transformed cleanly (no pixelation or blurring on sheer or warps), and effects (borders, edging, drop shadows, whatever) can be applied more easily/more consistently.

As far as sub-pixel accuracy goes, graphic cards are way ahead of what an artist can do manually.  You can go much more than 4x AA if you so desire (most cards support 16xAA and some even higher) but even at 4x you're looking at amazingly smooth edges.

I'm not saying that hand drawn pixel art is bad.  But converting a high res vector art image to a low res pixel image seems a step backwards IMO.

stop torturing yourself with obsolete limitations, just use the rendered image.

I'm always wondering how applying software lighting effects and other filters applies to the concept of PA, which traditionally is all about the artist doing every pixel by hand, to create the piece. Lighting and stuff can make some interesting pieces for sure, but I'm not quite sure its really in the spirit of PA anymore at that point.

It's a good idea, but the rationale (that pixel art is hard) is the wrong reason to do it. I think there's plenty of awesome ways we can create new types of visuals, and this is one of them. You are using the 3D scene as a model for an AI artist to "draw" from, which is awesome, however as others have pointed out, that is the BIG PROBLEM, and would require a lot of interesting research, as well as probably mastering the art of pixel art yourself in order to be able to design the system. However, if you could do all this, then the result could be really quite amazing.

I met Harold Cohen once (one of the first generative computer artists). He built a system back in the 70s called Aaron, which draws scenes with figures, plants, etc, all from a large set of rules, starting from the basics of how to draw a closed shape and colour it in, all the way up to what a hand looks like, how a human is constructed, how perspective works, etc. This stuff is pretty amazing and has a huge potential. One day I plan on making a game where scenes are generated algorithmically and then drawn and constructed using a similar AI approach. :)

Sorry, but these pictures I did can't be created using simple 3D rendering:

(http://fc06.deviantart.net/fs71/f/2012/305/c/0/alucard_hd_by_cristianceron-d5jnb4c.png)(http://fc00.deviantart.net/fs71/f/2012/331/5/6/athena_practice_sprite_by_cristianceron-d5md151.png)(http://fc00.deviantart.net/fs71/f/2012/332/6/2/pixel_art_practice_by_cristianceron-d5lhqf5.png)(http://fc04.deviantart.net/fs70/f/2012/129/7/3/a_sprite_of_ariel__by_cristianceron-d4z4db9.png)(http://)

Pixel art is not obsolete, it's an artistic choice, we need to upgrade and automate the way is done, sorry but besides this, it opens interesting new ways to create new art and visuals.

If you want professional examples look at SNK:
http://www.youtube.com/watch?v=Re-MX_TJFg4 (http://www.youtube.com/watch?v=Re-MX_TJFg4)

Sounds a bit like the polygon editor ( sans edges & bones ) for Another World. Check out the postmortem (http://www.gdcvault.com/play/1014630/Classic-Game-Postmortem-OUT-OF) starting at 11:20.

What you have here is basically what the rasterizer in your videocard or your average scanline software render already does. What makes pixelart pixelart is the purely aesthetic choices of where each individual pixel goes, the shading ramps, etc. It's probably possible to make a renderer that does that, but it would definitely not be this simple.

Excuse my ignorance of pixel art, but what is the advantage of making polygons over direct pixel painting?

The only advantage I can think is animation. Making the triangle rotate and then transform it to pixel may be easier than painting every frame (and can be done by the engine itself too) but pixel art usually paints shadows and reflections, and the method doesn't help there.

There are many advantages to using a different representation. Practically 100% of 3D games use polygons that are then converted into pixels. The OP's idea is basically to use a different polygon->pixel process than traditional rasterisation, one that is based more on the principles of pixel art.

the major reason that pixel art was born is because it is "readable" at low resolutions. you cannot simply take a 64x64 image and shrink it down to 16x16 and expect it to be as "readable" as a hand crafted sprite.
this is a good discussion (http://www.polycount.com/forum/showthread.php?t=97311) on creating pixel art from a 3D proggy. note that without hand crafting i believe you cannot get a resolution below 64x64 that is readable

Referencing a polycount thread that reference a tigsource tigs, now that's threadception for you O.O

haha. too true

Any process that goes into that hand crafting can, at least in theory, be written into code. Don't think anyone has succeeded in this so far, though.

that seems to imply that pixel artists are not in fact artists but laborers who translate a set of rules into images.

You are getting into a whole mess of worms here.  Theoretically, a human brain can be written into code (if we accept that a human brain is a deterministic machine [which given that there appears to be no faculty for quantum manipulation by the brain is probably a fair assumption]), but that doesn't make it a tractable problem. 

When your solution to a problem is essentially the Chinese Room, you might want to reassess your solution.

You don't have to simulate the whole human brain in order to be able to create low-res pixelart. I agree with powly, it could theoretically be possible to find these rules and write them into code.

I'm not saying you have to simulate the entire brain, but you are getting there.  I'm just saying it's naive to think that you can codify enough rules of art to be able to produce good results.  I'm not saying it's impossible, I grant you that it's fully possible (on some time scale, with enough memory and processing capability).

I'm just saying if you think you can take something as amorphous as pixel art (even if that art has a set of generally agreed upon rules) and completely and fully codify every aspect into a comprehensive set of rules to apply, you might want to reassess the feasibility of that.  Because you've essentially created a weak AI at that point.

Most non-photorealistic rendering techniques get away with things because the margin of error is pretty high.  If a cel-shading outline is a couple pixels off of what an actual human would do, that typically goes unnoticed.  If a pixel-art-shaded outline is a couple pixels off, it could look completely junky (depending on the target faux-resolution).

You don't have to leave everything up to the computer. You can just write most of the basic rules, generate a few variations and let the user decide which one looks best. I'm talking here about a generator though. Not about a "realtime" system which creates a specific pixel-art all by itself depending on the resolution, you're running a game in. That is a wholly different thing.

Oh, certainly.  A pixel-art facilitator is certainly a reasonable/doable thing. 

And beyond is certainly achievable. This video (http://This video) that demonstrates how Disney's Paperman short fused 3d art and cel animation shows the basics of what you would want to do.  But there's still a human in the loop to clean stuff up (which as I mentioned is going to be even more important for pixelart).

I think this is a worthy goal: putting a semi-intelligence in-between the internal representation of the world and the presentation to the user. Right now (in 3D games) its basically a set of rules that roughly models the physics of light, coupled with various simple rules about highlighting things on screen, outlining them etc., It's about time we saw more intelligent approaches to visual representation.

What it implies is that what a human brain can do, a computer can too. And on a very high and abstract level, you're correct. There are existing and findable rules in every single thing you can think of.

Also, I don't think I did a certain part of my previous post clearly enough, so let me reform it a bit:

But an ai isn't just a magical brain with a thought of his mind that decide things ex nihilo. It's funny when people freak out at AI and say there is a need for a human when actually there is human behind the AI too. Also there is a human behind the pencil or whatever tools! It only produce good result if the (many) man behind is (are) good too.