1) Should work, assuming your tree is centred around its origin. Otherwise you may need to offset your tree.

2) For long distance, don't bother with a high-res texture - takes longer to render, and might not be visible. 256 square should do fine. Yes, all should be the same size. Don't forget that your projection matrix must take into account the viewport size. Your eventual window doesn't matter. Don't forget to light it neutrally - coloured lights used for the imposter may cause problems when the imposter itself is lit - or you need to ensure that your imposters is lit when its texture is rendered, and NOT lit when it's rendered in your scene.

3)The billboards for imposters should be technically be TTF (turn-to-face). Don't confuse these with a manually drawn quad that you might use for sprites or HUD overlays. Basically their size is transformed according to the standard projection matrix based on their position (where your tree should be). Their original size (assuming the tree occupies the entire texture) should be the height of the tree object itself. This is covered in various tutorials about the place.

I don't really know the "Tom Miller's" method, but wouldn't it be simpler to pre-calc your billboards (in a rendering software such as Mays, 3DS, etc.) ?


For the 3), don't use billboards. Create a quad in world space, at the same place as the original tree, with the tree height, and aligned to the camera.

For example, this code will create the quad :



This will create a quad in the world space (so when the camera moves away or toward the tree, the size of the tree on screen changes) which has a height of "treeHeight" and a width of "treeWidth". And this quad is aligned with the camera (because we use the sideVector extracted from the view matrix)

Hope this helps ^^

Actually a more elegant way of doing that is to use a billboard set, rather than thrashing the allocator with creating a new quad every frame.

Rule of thumb: ctor's cost time- that includes D3DXVector. I really wouldn't create the quad for each tree, each frame, depending on view position. Honestly, the transformation math is much, much cheaper.(Edit: Especially if you're using any form of memory management, and aren't just creating things on the stack)

I'd suggest keeping a billboard set allocated (of quads, size as mentioned) that you assign to known tree locations as your LOD culler specifies, up to a certain number of imposter trees.

This also gives you the advantage that the billboard set can be placed into your scene and sorted according to shader (surface / texture / material) like any other renderable, saving shader changes, which again are costly in terms of time. Do bear in mind that alpha mapped objects have to be drawn from FAR to NEAR, unless you're using stencil buffering, which has many better uses. Since imposters are generally distant objects, you can basically sort the active billboard list for the set by depth, render solids, then your imposters, then your transparent objects.

Hi again.

For the alpha part, yes, I think it's the right method.

For the "flicker", it can come from 2 things :

- The size of the billboard. Using a bounding sphere is not really accurate to compute the size of the billboard. You could use a bouding box, it would be a lot more accurate.

- The rendering to texture. To have a good size, you should make sure that the tree occupies all the screen (in height at least), so when setting your view / projection matrices for the render-to-texture, you have to use a FOV and to place the camera at a distance such as your tree will fill the wholde texture.
For example, if you place your camera too far from the tree, then the tree will occupy only 50% of the texture, and even if the billboard's size is right, it will look smaller than the tree.