BSP for static environments along with z-buffering for dynamic moving object’s seems to be the simplest approach, but perhaps not the fastest, i’m not sure. AFAIK the quake engine used a similar approach.

The library is going to be pretty generic with nothing fancy like particle systems and only elementary lighting/shading somewhere down the line. I’m aiming at original playstation or N64 graphics, if that, as I don’t think flash needs or can handle anything more.

I want it to handle pretty much any scene I thow at it, i.e indoor/outdoor, landscapes, high buildings etc. Octree’s or ABT’s seem suited to most of this wheras BSP’s are apparently best suited only for indoor type scenes; and then i’ve read about combinations of the two.. having BSP trees at the leaf nodes of octrees.

What a headache! I suppose i’ll just pick one solution and run with it after a bit more reading. The problem is a lot of literature includes using these methods in conjunction with the GPU, and i’m dealing with software only.

Thanks for the pointers.

BSP tends to be good for static data, as you mention, but constructing an optimal BSP tree is a mess that you don’t want to do at runtime. Other tree structures, such as ABT or Octrees, can be useful as well, especially if you combine them with simple culling procedures without pre-computations (such as antiportals). Two issues can get quite annoying, though:

- You have to decide how your non-scene objects occlude each other (self-occlusion can be handled through an appropriate sort algorithm): are they drawn as a whole, in order, or can two objects occlude each other?
- You have to cull all polygons that are behind the camera. This can be quite annoying, because it has to be done on a per-polygon basis, so you want to rely on backface culling as much as you can.

All of this points towards splitting your objects into convex or concave sub-sections that are handled as a whole (to avoid handling individual polygons) so that mutual occlusion does not happen and backface culling is enough to eliminate backfaces if you can see only part of a sub-section.

I’m trying to build a 3d engine using the new flash stuff, but i’m unsure of how to handle the depth sorting or occlusion culling. Since there is no access to the GPU it needs to be a fast software only solution. I’ve read about BSP tree’s and understand that they don’t handle dynamic changes all that well which is important. I also read that bsp can be used for static polygons and something else for movable objects.

Given what’s available do you think you could recommend the fastest method or algorithm for depth and culling? No problem if not, just thought i’d ask.

Thank you.

I am puzzled as to why you chose to write your own projection algorithm rather than use Utils3D.projectVectors() which is part of the new Graphics API.

Surely the in-built projector is faster, being written directly into the flash player, as opposed to actionscript code which has to be interpreted and doesn’t have the benefit of low-level memory management, or other techniques for improving algorithm speed.

Perhaps i’m wrong, you seem to know a lot more about this than me.

The complexity of ordering triangles seems likely to outweigh the benefits of using the routines! Sorrow!

Maybe flash 11 will add a drawTrianglez method…

Small comment:
“(this is what the TnL revolution was: Texture and Lighting)”
TnL is an acronym for Transform and Lighting not Texture and Lighting.