Suggestion for Renderable interface

[remleduff]

I think it would be convenient if there was some sort of distinction between when a renderable that performs it's openGL setup and when it does its actual drawing.

I have the following picture in my head that would add a little consistency to parts of the codebase.

public interface Renderable {
    
     /**
     * Causes this <code>Renderable</code> to render itself using the <code>DrawContext</code> provided. The
     * <code>DrawContext</code> provides the elevation model, openGl instance, globe and other information required for
     * drawing. It is recommended that the <code>DrawContext</code> is non-null as most implementations do not support
     * null <code>DrawContext</code>s.
     *
     *  The expectation is that the Renderable will perform any necessary
     *  openGL setup, and then use its draw method to perform the actual drawing,
     *  though this is not required (ie for Renderables that use batched rendering)
     *
     * @param dc the <code>DrawContext</code> to be used
     * @see DrawContext
     */
    public void render(DrawContext dc);

    /**
     *  Causes this Renderable to render itself using the DrawContext provided
     *  using the current OpenGL state.
     */
    public void draw(DrawContext dc);

}


// This could be an abstract class with an abstract draw method 
// but I implemented it this way to ease with migrating the current codebase
public class BasicRenderable implements Renderable {

    /**
     * Set up the OpenGL state for this Renderable to be rendered.
     *  This method is intended to be overriden by subclasses
     */
    public void beginRendering() {}

    /**
     * Restore the OpenGL state to its previous value (ie using glPopAttrib()).
     *  This method is intended to be overriden by subclasses
     */
    public void endRendering() {}

    public void render() {
        try {
            beginRendering();
            draw();
        }
        finally {
            endRendering();
        }
    }

    public void draw() {
        throw new UnsupportedOperationException();
    }

}

[zerobarrier]

I believe that is the correct intent. However, you shouldn't modify the Renderable interface IMO.

I created my own rendering framework that sits on top of WWJ. I have a hierarchy of entities, all of which are derived from a common interface. Furthermore, I generally extend from a standard implementation that has doPreRender(), doRender(), and doPostRender() methods (Entity->BasicEntity->*Entity). Much like WWJ, I use a prefix of do* in order to further control the rendering process (e.g. frustum culling, where the do* methods aren't called if the entity is not visible in the frustum).

[remleduff]

Well, I was mostly suggesting a change for the WW code that I thought would be useful, I can of course do whatever I want in my own code.