package org.open2jam.render;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.net.URL;
import org.open2jam.GameOptions;
import org.open2jam.render.lwjgl.LWJGLGameWindow;
import org.open2jam.render.lwjgl.LWJGLSprite;
/**
* A central reference point for creating resources for use in the game. The resources
* return may be implemented in several different rendering contexts but will also
* work within the GameWindow supplied from this class. For instance, a Sprite retrieved
* as a resource will draw happily in the GameWindow supplied from this factory
*
* @author Kevin Glass
*/
public class ResourceFactory {
/** The single instance of this class to ever exist <singleton> */
private static final ResourceFactory single = new ResourceFactory();
/**
* Retrieve the single instance of this class
*
* @return The single instance of this class
*/
public static ResourceFactory get() {
return single;
}
/** A value to indicate that we should use OpenGL (LWJGL) to render our game */
public static final int OPENGL_LWJGL = 1;
/** The type of rendering that we are currently using */
private int renderingType = OPENGL_LWJGL;
/** The window the game should use to render */
private GameWindow window;
/**
* The default contructor has been made private to prevent construction of
* this class anywhere externally. This is used to enforce the singleton
* pattern that this class attempts to follow
*/
private ResourceFactory() {
}
/**
* Set the rendering method that should be used.
* This can only be done before the first resource is accessed.
* @param renderingType The type of rendering to use
*/
public void setRenderingType(int renderingType) {
// If the rendering type is unrecognised tell the caller
if (renderingType != OPENGL_LWJGL) {
// Note, we could create our own exception to be thrown here but it
// seems a little bit over the top for a simple message. In general
// RuntimeException should be subclassed and thrown, not thrown directly.
throw new RuntimeException("Unknown rendering type specified: "+renderingType);
}
// If the window has already been created then we have already created resources in
// the current rendering method, we are not allowed to change rendering types
if (window != null) {
throw new RuntimeException("Attempt to change rendering method at game runtime");
}
this.renderingType = renderingType;
}
/**
* Retrieve the game window that should be used to render the game
*
* @return The game window in which the game should be rendered
*/
public GameWindow getGameWindow() {
// if we've yet to create the game window, create the appropriate one
// now
if (window == null) {
switch (renderingType) {
case OPENGL_LWJGL:
{
window = new LWJGLGameWindow();
break;
}
}
}
return window;
}
/**
* Create or get a sprite which displays the image that is pointed
* to in the class-path by "ref"
*
* @param ref A reference to the image to load
* @return A sprite that can be drawn onto the current graphics context.
*/
public Sprite getSprite(URL ref, Rectangle slice) throws java.io.IOException {
if (window == null) {
throw new RuntimeException("Attempt to retrieve sprite before game window was created");
}
switch (renderingType) {
case OPENGL_LWJGL:
{
return new LWJGLSprite((LWJGLGameWindow) window,ref, slice);
}
}
throw new RuntimeException("Unknown rendering type: "+renderingType);
}
public Sprite getSprite(BufferedImage image) {
if (window == null) {
throw new RuntimeException("Attempt to retrieve sprite before game window was created");
}
switch (renderingType) {
case OPENGL_LWJGL:
{
return new LWJGLSprite((LWJGLGameWindow) window, image);
}
}
throw new RuntimeException("Unknown rendering type: "+renderingType);
}
public Sprite doRectangle(int width, int height, GameOptions.VisibilityMod type)
{
if (window == null) {
throw new RuntimeException("Attempt to retrieve sprite before game window was created");
}
switch (renderingType) {
case OPENGL_LWJGL:
{
return new LWJGLSprite(width, height, type);
}
}
throw new RuntimeException("Unknown rendering type: "+renderingType);
}
}