Any chance we could get an ALLEGRO_PRIM_QUAD primitive type? I am in need of a function that works like OpenLayer's Bitmap::BlitDistorted() function. I tried using triangles but the texture doesn't get stretched correctly.

I think you might be doing something wrong if the texture isn't applied correctly... But we don't have quads now because some hardware doesn't support them (some entire platforms don't support them)... I don't see any need. Maybe you could post your code?

The problem I'm having is I am wanting to do some simple 3D effects but with triangles I am not getting the correct perspective on the texture. Because each triangle is rendered separately I get one triangle with the texture stretched one way and the other with the texture stretched another way. The effect I want cannot be done with triangles without actually using 3D.

Sorry, I don't know what OpenLayer's Bitmap::BlitDistorted() does. Can you explain? Sometimes when you need a 3d effect, you need to use 3d?

Here is a description of the function:

Ok.. I'm not even sure how you would do that without shaders or making a bunch of triangles. I wouldn't add it to Allegro, I think it's too specialized but wait for the smart people to speak.

Trent, BlitDistorted actually uses a quad, here it is in case you want to take a loot at it:

If the hardware supports it, quads could be a useful addition. If a software fallback routine isn't hard to do.

It's not clear to me what that function does, or why you couldn't do the same thing by splitting the thing up into two triangles (as long as you order your vertices correctly and set the texture coordinates properly), however it seems to me you could just use a textured polygon?

To me it sounds like you could place your vertices anywhere you like, so you could create a flattened out mobius strip, which is twisted so can't be rendered by two triangles AFAIK.

Here's what it looks like when I use triangles:

{"name":"Screenshot-EOF%20Audition-1.png","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/4\/4\/44024acc4a3d7d543c3c9d1231bb858b.png","w":640,"h":480,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/4\/4\/44024acc4a3d7d543c3c9d1231bb858b"}

Here's the original texture:

{"name":"neck.png","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/b\/c\/bc919f4302dab4e56a4de6097e031646.png","w":512,"h":1024,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/b\/c\/bc919f4302dab4e56a4de6097e031646"}

Dario, missed your post... I think I understand now. It still plays by the rules of regular opengl quads. Basically it can draw trapezoids and other weird shapes but the vertices must be planar... So I think quads would be useful to simplify this stuff, though I'm not convinced it couldn't be done with triangles.

It can be done with triangles, but as the posted example shows, you can't do it with just two (four will work: chop off the slanted sides, then split the remaining rectangle in two).
I would still say that a textured polygon should work, but that may have the same issue (not sure).

Using GL_QUADS results in the same output as triangles.

Output:
{"name":"601548","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/2\/4\/24b3b452b84845d7eb51487dcb436b6d.png","w":800,"h":800,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/2\/4\/24b3b452b84845d7eb51487dcb436b6d"}

I would've guessed that since the original function was using QUADs the texture's mapping would be fixed... but why does the mapping in your example look like it was done with 2 triangles?

The graphics card breaks a quad into two triangles. Everything is done in triangles at the lowest level of the gpu.

Because it is done like that internally. GL_QUADS is just a convenience type. Internally, OpenGL tesselates the quad into two triangles. For Todd Cope to get what he wants he needs to either:

1. Use perspective (primitives addon in principle supports this in hardware mode)

2. Approximate the effect using more triangles (e.g. in the way Evert suggested)

Note that without the third dimension you can never get the proper mapping (unless your vertices are arranged in a particular way) because the generic quad to quad mapping is non-affine... and without 3D, only affine mappings can be done. You can get a good approximation by throwing more triangles at it, but it won't be exact in the general case.

I see. I'm getting the same here... the only difference is that the image seems to be flipped horizontally.

Assuming that the projection matrix is set up as an orthogonal projection, you can get the effect with just 2 triangles and playing with the z coordinate. A bit of trigonometry should give you what z values you need to use.

Well if the output he expects is what I think (the horizontal lines won't be equidistant).

I thought with an orthographic projection, z value didn't matter and distant objects appear in line with close objects, i.e., there is no way to tell tell distance of anything.

Now I'm starting to not be sure about what OpenGL would output doing that. I would think that the z coordinate would be used to perform the perspective correction and you could get the desired output that way (it's a bit of a hack/trick actually). But I haven't used OpenGL in a lot of time and now I'm unsure about that.

I think you need a perspective projection for that, not an orthographic projection.

Can't we just investigate on OpenLayer's setup and see how it setups the projections?

The point I was getting at is that OpenLayer does it wrong also, since it uses the GL_QUADS in the same way I did: a single quad on a plane. In that configuration the perspective does not matter, since the quad is parallel to the viewing plane. It'd be nice if someone with OpenLayer could confirm this.

AFAIK, OpenLayer sets up an ortographic projection like this:

    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadIdentity();
    glOrtho( 0, w, 0, h, -1, 1000 );
    glScalef( 1, -1, 1 );
    glTranslatef( 0, -h, 0 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glDisable( GL_DEPTH_TEST );

There must be something else though, but I'm looking for any clues. If you want, I'll attach OpenLayer's source here.

EDIT: Ok, here it is. I took away the demos, but I just 7-zipped the old package I had. Download.

As far as I can see, the correct mapping would have to be in 3d with the bottom vertices near the camera, and the top vertices in the distance, but the vertices are actually a square in 3 space. Using an orthgraphic projection would show this as a square every time.

OpenLayer's alternative BlitDistorted function actually uses a GL_TRIANGLE_FAN.

Well, do you have a screenshot how it looks in OpenLayer?

How curious, after months of not using it, it doesn't seem to be able to do this as well.
{"name":"601562","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/5\/2\/52818de022201e6db00ac0c433f54981.jpg","w":795,"h":602,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/5\/2\/52818de022201e6db00ac0c433f54981"}
I remember it working perfectly. Maybe this case is hard to do?

Ok, so we don't want a function that "works like OpenLayer's Bitmap::BlitDistorted" but a new function nobody has ever done yet...?

Seems like too much of a hassle to me. I thought it would be something simple but from the looks of it this is something that is best left to being done in 3D. I retract my request.

Googling a bit I found this paper from 2004. It sounds like a method to do what you want: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.62.7170&rep=rep1&type=pdf

It requires a hardware implementation though and doesn't seem like any hardware supports it, they all just use triangles. OpenGL ES 1 and 2 as well as normal OpenGL 3 and 4 even removed the GL_QUAD primitives completely. So yes, your best bet is to just use one of the methods suggested in this thread to achieve it, in your own code.