Cool, the computer at work gets 2 frames per second on that. ;) I haven't dared check what the hertz is on this baby.

This is very good. I was thinking about making my own 3D engine when I had the time.

It also gets a lot of FPS. 3/100 centisecs on my PC = approx 33 frames per second.

We'll talk. Does it have any kind of Z-ordering or clipping or anything?

If you've got matrix rotation down, too, then you've got a great grasp of this stuff. I'm just now beginning to understand it...

Okay, more talk time.

You've got z-sorting..which is really. Good.

Is this just a demo, or are you planning on refining it for general usage?

There's a bit I'd like to know about the demo. Does it support hierarchial object model spaces?

I've got my own idea for a 3D engine...uh...API thingagummie. Basically, all the data is in arrays, like yours. But you are given handles to the arrays. Like:

int vectors[TOTAL_VECTORS][4];





int V(int x, int y, int z)


{


Create vector in the vectors array, and return the pointer.


}





myvector = V(500, 200, 30);





DrawVector(myvector);

Stuff like that. All the drawing functions would look in the arrays at the given location for the drawing info. The idea is that it should be nearly second-nature to throw together a polygon on a single line of code.

I'm still working on hierarchial object models..I can't figure how I should do it, since V3 can't nest structs.

This is assuming, of course, that I ever actually get around to programming it.

You've done that, which is really cool. 3D is really a viable thing to do with Verge3...it doesn't mean you need a whole bunch of polygons and huge models, but just 3D mathematics in general is pretty neat. Great job!

Yes, z sorting is in. I looked at z buffering but it would entail having to rewrite the triangle function. The exisiting one is fast enough for me and besides z-sorting is good enough for most purposes. I almost had lambert shading in, but was having some trouble getting the triangle normals pointing the right way.

At present it can handle a maximum of 550 triangles, any higher and it crashes in what seems to be the recursive quicksorting. Don't fully understand the situation though. It can go much much higher with bubble sorting, but consequently it slows to a crawl.

"Does it support hierarchial object model spaces?" I don't know what that is, so no. I learnt just enough about 3d rendering to create this, I'm still pretty ignorant about the subject.

And at present I don't have any plans to take it further, at least not for a while. The uni break is over and this has been a large source of distraction. It was too much fun to abandon it forever though :)

Okay, hierarchial object models...quick lesson.

Your head. It can rotate 90 degrees clockwise or counterclockwise, right?

It also has a relative position: of being on top of your body.

This is a hierarchial object. The head object, which has it's own angle and position, is a child of the "body" object.

To render a hierarchial object, you render the highest level (the body), then you use the body's position to calculate the head's position (ie, the head MUST be 60 centimeters from the torso). You then calculate the sub-object (head)'s angle using the angle of the torso.

For example, if the body is rotated 90 degrees, then the head is of course rotated 90 degrees. But if the head is turned clockwise, it is rotated even further.

You do this in object space. Translate the head and angle it in object space, then position it in the object space of the torso.

That's...basically a hierarchial model. Make sense?

Don't worry, this is still a great job.

Basil, this is so uber awesome it's silly.

I don't dare look at the codebase yet, being busy, but would you rate it as capable of doing 3d things like adding rotating 3d polys into a 2d battle system for various wacky spell effect fun?

"would you rate it as capable of doing 3d things like adding rotating 3d polys into a 2d battle system "
I guess you could, but it would depend what you had in mind. I didn't get time to investigate camera functionality, but from what I gather it's not a great deal more calculation. With a proper camera you could do all kinds of nutty things. When I think about it that's probably the best idea for actually implementing something like this. I'd love to see it, so somebody go work on it :P

If you were going to look into something like that I guess you'd need some proper animation techniques rather than just specifying angles and displacements. By the way, object scaling can also be done with extreme ease, I just didn't put it in as I didn't see a need for it.

As for the z sorting, yeah it's probably the best bet. It has some wierdness every now and again, but if I'm not mistaken it was all the Playstation had and it did fine. To answer your question, it's based off the sum of the z values of the 3 vertices.

And textures would be very cool indeed, but well beyond what I can pull off. I recall Skarlath had something of the sort in v2, but I don't have his script anymore. Skarlath was a bit of a legend really.

Well, in most 2d battle systems, you're loking at a static camera, so you really don't need to worry about moving the POV.

Well, when I say camera I mean a moveable point of view. So instead of always projecting onto the screen as if you are looking down the z axis you create the illusion of moving all around the object. What you described above is in effect what's going on currently.

But both of you are correct, you wouldn't need a camera for such a purpose. I'll have a think about it, it definitely warrants some investigation...

Huh. The Saturn used Z-sorting.

Which, I was wondering. The Playstation uses three-sided primitives (triangle polygons), right? And I'm certain the Saturn uses four-sided quads. Now, technically, a quad is made of two triangles.

The Saturn's polygons per second rate is 200,000, and I think the Playstation's is a little bit more...but don't you think the above means that the Saturn is actually rendering twice as many three-sided polygons as the Playstation?

I don't know how many polygons we could get Verge to render if we could avoid any memory problems, but I bet it'd be less than a Sega 32X.

Which, by the way, I tried to declare the three arrays for vectors, matrixes, and quads in Verge. Each array was size 200,000. I think Verge crashed.

At one point, I used 200,000 only for vectors and matrixes, and Verge was happily consuming near 20 megs of memory, but I just decided there was no way I was gonna use that much RAM when Verge couldn't really draw 200,000 anyway. I think I cut it down to 50,000 for quads and matrixes, or something.

Pipe dreams :)