In an accelerated environment the scene is drawn on the card and goes directly from there onto the screen. In order to draw directly over the scene it must be rendered, then transfered to the system memory, drawn on, then tranfered back. Each of these transfers take place on the bus between the card and the system which is already busy with the normal operations of displaying everything not 3d on the screen. Using a texture that is placed in front of the image plate is a much cheaper operation. It just requires transering the data to the card once (as oppoased to the whole scene back and forth across the bus for each frame.) Also OverlayBase which is the default implementation of this interface is double buffered so the transfer takes place in the background and once the entire texture make it onto the card it is made active.
Creating a new Overlay is very simple. Simply override paint(Graphics2D g) in OverlayBase. If you have an overlay that is changing with time calling repaint() will update it.
As a note: Displaying large overlays use a *huge* amount of texture memory. Every pixel in the overlay is represented by a set of integers (3 or 4 depending on if the overlay has a transparency value (RGB vs RGBA.) For a 512x128 alpha capable overlay that is (4 * 512 * 128) / 1024 = 256Kb of memory. Each texture has 3 buffers though, one in system memory and two on the card so the actual memory used is 256Kb * 3 = 768Kb. A 512x512 overlay would take 3072Kb or 3Mb.
Another thing to realize is that textures have to have dimesions that are powers of two for optimization purposes. This means a 513x257 texture would require 1024x512 of bounds to be allocated. Unlike most textures, overlays cannot tolerate stretching and interpolation because of the fuzzyness that results. The overlay system breaks the requested overlaysize up into smaller pieces so that extra texture memory is not wasted. This is hidden from the user who simply sees a graphics context for the entire overlay. When the entire buffer has been drawn though it is divided appropriately onto the SubOverlay's which are positioned so as to look like one solid rectangle.
Updates to the actual textures are done within a behavior within a frame. This is very fast because all that is happening is that the buffers are getting swapped. We have to be certain that we are not in the process of copying the big buffer into the back buffer at the same time the behavior attempts to do a buffer swap. This is handled by the overlay by not updating texture if we are in the middle of drawing a new one. The drawback to this is that numerous updates per second to the overlay could result in several updates not get immediately reflected. But since the area is always completely redrawn this should not prove to be an issue. Soon as we hit a frame where we are not updating the buffer then it will be swapped.
Remember, all you have to do to make translucent or non-square overlays is to use the alpha channel.
Field Detail |
public static final int BACKGROUND_NONE
public static final int BACKGROUND_COPY
Method Detail |
public void initialize()
public javax.media.j3d.BranchGroup getRoot()
public java.awt.Rectangle getBounds()
public boolean contains(java.awt.Point p)
p
- The point to check if it is containedpublic org.j3d.geom.overlay.UpdateManager getUpdateManager()
The
- update manage instance for this overlaypublic void setUpdateManager(org.j3d.geom.overlay.UpdateManager updateManager)
updateManager
- A reference to the new manage instance to usepublic void setLocation(int x, int y)
x
- The x coordinate of the locationy
- The y coordinate of the locationpublic void setSize(int w, int h)
w
- The new width of the overlayh
- The new height of the overlaypublic void setAntialiased(boolean isAntialiased)
isAntialiased
- true if this overlay should antialias the linespublic boolean isAntialiased()
public void setVisible(boolean visible)
visible
- true to make the overlay visiblepublic boolean isVisible()
public void setComponentDetails(java.awt.Dimension size, double fov)
size
- The new dimensions of the componentfov
- The new field of view for the current view