mirror of
https://github.com/curioustorvald/Terrarum.git
synced 2026-03-08 12:51:51 +09:00
d3080ffb78
Former-commit-id: 1647fa32ef6894bd7db44f741f07c2f4dcdf9054 Former-commit-id: 0e5810dcfbe1fd59b13e7cabe9f1e93c5542da2d
769 lines
20 KiB
Java
769 lines
20 KiB
Java
package org.newdawn.slick;
|
|
|
|
import java.io.IOException;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.IntBuffer;
|
|
|
|
import org.lwjgl.BufferUtils;
|
|
import org.newdawn.slick.opengl.ImageData;
|
|
import org.newdawn.slick.opengl.ImageDataFactory;
|
|
import org.newdawn.slick.opengl.LoadableImageData;
|
|
import org.newdawn.slick.opengl.Texture;
|
|
import org.newdawn.slick.opengl.renderer.SGL;
|
|
import org.newdawn.slick.opengl.renderer.Renderer;
|
|
import org.newdawn.slick.util.OperationNotSupportedException;
|
|
import org.newdawn.slick.util.ResourceLoader;
|
|
|
|
/**
|
|
* An image implementation that handles loaded images that are larger than the
|
|
* maximum texture size supported by the card. In most cases it makes sense
|
|
* to make sure all of your image resources are less than 512x512 in size when
|
|
* using OpenGL. However, in the rare circumstances where this isn't possible
|
|
* this implementation can be used to draw a tiled version of the image built
|
|
* from several smaller textures.
|
|
*
|
|
* This implementation does come with limitations and some performance impact
|
|
* however - so use only when absolutely required.
|
|
*
|
|
* TODO: The code in here isn't pretty, really needs revisiting with a comment stick.
|
|
*
|
|
* @author kevin
|
|
*/
|
|
public class BigImage extends Image {
|
|
/** The renderer to use for all GL operations */
|
|
protected static SGL GL = Renderer.get();
|
|
|
|
/**
|
|
* Get the maximum size of an image supported by the underlying
|
|
* hardware.
|
|
*
|
|
* @return The maximum size of the textures supported by the underlying
|
|
* hardware.
|
|
*/
|
|
public static final int getMaxSingleImageSize() {
|
|
IntBuffer buffer = BufferUtils.createIntBuffer(16);
|
|
GL.glGetInteger(SGL.GL_MAX_TEXTURE_SIZE, buffer);
|
|
|
|
return buffer.get(0);
|
|
}
|
|
|
|
/** The last image that we put into "in use" mode */
|
|
private static Image lastBind;
|
|
|
|
/** The images building up this sub-image */
|
|
private Image[][] images;
|
|
/** The number of images on the xaxis */
|
|
private int xcount;
|
|
/** The number of images on the yaxis */
|
|
private int ycount;
|
|
/** The real width of the whole image - maintained even when scaled */
|
|
private int realWidth;
|
|
/** The real hieght of the whole image - maintained even when scaled */
|
|
private int realHeight;
|
|
|
|
/**
|
|
* Create a new big image. Empty contructor for cloning only
|
|
*/
|
|
private BigImage() {
|
|
inited = true;
|
|
}
|
|
|
|
/**
|
|
* Create a new big image by loading it from the specified reference
|
|
*
|
|
* @param ref The reference to the image to load
|
|
* @throws SlickException Indicates we were unable to locate the resource
|
|
*/
|
|
public BigImage(String ref) throws SlickException {
|
|
this(ref, Image.FILTER_NEAREST);
|
|
}
|
|
|
|
/**
|
|
* Create a new big image by loading it from the specified reference
|
|
*
|
|
* @param ref The reference to the image to load
|
|
* @param filter The image filter to apply (@see #Image.FILTER_NEAREST)
|
|
* @throws SlickException Indicates we were unable to locate the resource
|
|
*/
|
|
public BigImage(String ref,int filter) throws SlickException {
|
|
|
|
build(ref, filter, getMaxSingleImageSize());
|
|
}
|
|
|
|
/**
|
|
* Create a new big image by loading it from the specified reference
|
|
*
|
|
* @param ref The reference to the image to load
|
|
* @param filter The image filter to apply (@see #Image.FILTER_NEAREST)
|
|
* @param tileSize The maximum size of the tiles to use to build the bigger image
|
|
* @throws SlickException Indicates we were unable to locate the resource
|
|
*/
|
|
public BigImage(String ref, int filter, int tileSize) throws SlickException {
|
|
build(ref, filter, tileSize);
|
|
}
|
|
|
|
/**
|
|
* Create a new big image by loading it from the specified image data
|
|
*
|
|
* @param data The pixelData to use to create the image
|
|
* @param imageBuffer The buffer containing texture data
|
|
* @param filter The image filter to apply (@see #Image.FILTER_NEAREST)
|
|
*/
|
|
public BigImage(LoadableImageData data, ByteBuffer imageBuffer, int filter) {
|
|
build(data, imageBuffer, filter, getMaxSingleImageSize());
|
|
}
|
|
|
|
/**
|
|
* Create a new big image by loading it from the specified image data
|
|
*
|
|
* @param data The pixelData to use to create the image
|
|
* @param imageBuffer The buffer containing texture data
|
|
* @param filter The image filter to apply (@see #Image.FILTER_NEAREST)
|
|
* @param tileSize The maximum size of the tiles to use to build the bigger image
|
|
*/
|
|
public BigImage(LoadableImageData data, ByteBuffer imageBuffer, int filter, int tileSize) {
|
|
build(data, imageBuffer, filter, tileSize);
|
|
}
|
|
|
|
/**
|
|
* Get a sub tile of this big image. Useful for debugging
|
|
*
|
|
* @param x The x tile index
|
|
* @param y The y tile index
|
|
* @return The image used for this tile
|
|
*/
|
|
public Image getTile(int x, int y) {
|
|
return images[x][y];
|
|
}
|
|
|
|
/**
|
|
* Create a new big image by loading it from the specified reference
|
|
*
|
|
* @param ref The reference to the image to load
|
|
* @param filter The image filter to apply (@see #Image.FILTER_NEAREST)
|
|
* @param tileSize The maximum size of the tiles to use to build the bigger image
|
|
* @throws SlickException Indicates we were unable to locate the resource
|
|
*/
|
|
private void build(String ref, int filter, int tileSize) throws SlickException {
|
|
try {
|
|
final LoadableImageData data = ImageDataFactory.getImageDataFor(ref);
|
|
final ByteBuffer imageBuffer = data.loadImage(ResourceLoader.getResourceAsStream(ref), false, null);
|
|
build(data, imageBuffer, filter, tileSize);
|
|
} catch (IOException e) {
|
|
throw new SlickException("Failed to load: "+ref, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create an big image from a image data source.
|
|
*
|
|
* @param data The pixelData to use to create the image
|
|
* @param imageBuffer The buffer containing texture data
|
|
* @param filter The filter to use when scaling this image
|
|
* @param tileSize The maximum size of the tiles to use to build the bigger image
|
|
*/
|
|
private void build(final LoadableImageData data, final ByteBuffer imageBuffer, int filter, int tileSize) {
|
|
final int dataWidth = data.getTexWidth();
|
|
final int dataHeight = data.getTexHeight();
|
|
|
|
realWidth = width = data.getWidth();
|
|
realHeight = height = data.getHeight();
|
|
|
|
if ((dataWidth <= tileSize) && (dataHeight <= tileSize)) {
|
|
images = new Image[1][1];
|
|
ImageData tempData = new ImageData() {
|
|
public int getDepth() {
|
|
return data.getDepth();
|
|
}
|
|
|
|
public int getHeight() {
|
|
return dataHeight;
|
|
}
|
|
|
|
public ByteBuffer getImageBufferData() {
|
|
return imageBuffer;
|
|
}
|
|
|
|
public int getTexHeight() {
|
|
return dataHeight;
|
|
}
|
|
|
|
public int getTexWidth() {
|
|
return dataWidth;
|
|
}
|
|
|
|
public int getWidth() {
|
|
return dataWidth;
|
|
}
|
|
};
|
|
images[0][0] = new Image(tempData, filter);
|
|
xcount = 1;
|
|
ycount = 1;
|
|
inited = true;
|
|
return;
|
|
}
|
|
|
|
xcount = ((realWidth-1) / tileSize) + 1;
|
|
ycount = ((realHeight-1) / tileSize) + 1;
|
|
|
|
images = new Image[xcount][ycount];
|
|
int components = data.getDepth() / 8;
|
|
|
|
for (int x=0;x<xcount;x++) {
|
|
for (int y=0;y<ycount;y++) {
|
|
int finalX = ((x+1) * tileSize);
|
|
int finalY = ((y+1) * tileSize);
|
|
final int imageWidth = Math.min((realWidth - (x*tileSize)), tileSize);
|
|
final int imageHeight = Math.min((realHeight - (y*tileSize)), tileSize);
|
|
|
|
final int xSize = tileSize;
|
|
final int ySize = tileSize;
|
|
|
|
final ByteBuffer subBuffer = BufferUtils.createByteBuffer(tileSize*tileSize*components);
|
|
int xo = x*tileSize*components;
|
|
|
|
byte[] byteData = new byte[xSize*components];
|
|
for (int i=0;i<ySize;i++) {
|
|
int yo = (((y * tileSize) + i) * dataWidth) * components;
|
|
imageBuffer.position(yo+xo);
|
|
|
|
imageBuffer.get(byteData, 0, xSize*components);
|
|
subBuffer.put(byteData);
|
|
}
|
|
|
|
subBuffer.flip();
|
|
ImageData imgData = new ImageData() {
|
|
public int getDepth() {
|
|
return data.getDepth();
|
|
}
|
|
|
|
public int getHeight() {
|
|
return imageHeight;
|
|
}
|
|
|
|
public int getWidth() {
|
|
return imageWidth;
|
|
}
|
|
|
|
public ByteBuffer getImageBufferData() {
|
|
return subBuffer;
|
|
}
|
|
|
|
public int getTexHeight() {
|
|
return ySize;
|
|
}
|
|
|
|
public int getTexWidth() {
|
|
return xSize;
|
|
}
|
|
};
|
|
images[x][y] = new Image(imgData, filter);
|
|
}
|
|
}
|
|
|
|
inited = true;
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#bind()
|
|
*/
|
|
public void bind() {
|
|
throw new OperationNotSupportedException("Can't bind big images yet");
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#copy()
|
|
*/
|
|
public Image copy() {
|
|
throw new OperationNotSupportedException("Can't copy big images yet");
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw()
|
|
*/
|
|
public void draw() {
|
|
draw(0,0);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, org.newdawn.slick.Color)
|
|
*/
|
|
public void draw(float x, float y, Color filter) {
|
|
draw(x,y,width,height,filter);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float, org.newdawn.slick.Color)
|
|
*/
|
|
public void draw(float x, float y, float scale, Color filter) {
|
|
draw(x,y,width*scale,height*scale,filter);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float, float, org.newdawn.slick.Color)
|
|
*/
|
|
public void draw(float x, float y, float width, float height, Color filter) {
|
|
float sx = width / realWidth;
|
|
float sy = height / realHeight;
|
|
|
|
GL.glTranslatef(x,y,0);
|
|
GL.glScalef(sx,sy,1);
|
|
|
|
float xp = 0;
|
|
float yp = 0;
|
|
|
|
for (int tx=0;tx<xcount;tx++) {
|
|
yp = 0;
|
|
for (int ty=0;ty<ycount;ty++) {
|
|
Image image = images[tx][ty];
|
|
|
|
image.draw(xp,yp,image.getWidth(), image.getHeight(), filter);
|
|
|
|
yp += image.getHeight();
|
|
if (ty == ycount - 1) {
|
|
xp += image.getWidth();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
GL.glScalef(1.0f/sx,1.0f/sy,1);
|
|
GL.glTranslatef(-x,-y,0);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float, float, float, float, float, float)
|
|
*/
|
|
public void draw(float x, float y, float x2, float y2, float srcx, float srcy, float srcx2, float srcy2) {
|
|
int srcwidth = (int) (srcx2 - srcx);
|
|
int srcheight = (int) (srcy2 - srcy);
|
|
|
|
Image subImage = getSubImage((int) srcx,(int) srcy,srcwidth,srcheight);
|
|
|
|
int width = (int) (x2 - x);
|
|
int height = (int) (y2 - y);
|
|
|
|
subImage.draw(x,y,width,height);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float, float, float, float)
|
|
*/
|
|
public void draw(float x, float y, float srcx, float srcy, float srcx2, float srcy2) {
|
|
int srcwidth = (int) (srcx2 - srcx);
|
|
int srcheight = (int) (srcy2 - srcy);
|
|
|
|
draw(x,y,srcwidth,srcheight,srcx,srcy,srcx2,srcy2);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float, float)
|
|
*/
|
|
public void draw(float x, float y, float width, float height) {
|
|
draw(x,y,width,height,Color.white);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float)
|
|
*/
|
|
public void draw(float x, float y, float scale) {
|
|
draw(x,y,scale,Color.white);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float)
|
|
*/
|
|
public void draw(float x, float y) {
|
|
draw(x,y,Color.white);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawEmbedded(float, float, float, float)
|
|
*/
|
|
public void drawEmbedded(float x, float y, float width, float height) {
|
|
float sx = width / realWidth;
|
|
float sy = height / realHeight;
|
|
|
|
float xp = 0;
|
|
float yp = 0;
|
|
|
|
for (int tx=0;tx<xcount;tx++) {
|
|
yp = 0;
|
|
for (int ty=0;ty<ycount;ty++) {
|
|
Image image = images[tx][ty];
|
|
|
|
if ((lastBind == null) || (image.getTexture() != lastBind.getTexture())) {
|
|
if (lastBind != null) {
|
|
lastBind.endUse();
|
|
}
|
|
lastBind = image;
|
|
lastBind.startUse();
|
|
}
|
|
image.drawEmbedded(xp+x,yp+y,image.getWidth(), image.getHeight());
|
|
|
|
yp += image.getHeight();
|
|
if (ty == ycount - 1) {
|
|
xp += image.getWidth();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawFlash(float, float, float, float)
|
|
*/
|
|
public void drawFlash(float x, float y, float width, float height) {
|
|
float sx = width / realWidth;
|
|
float sy = height / realHeight;
|
|
|
|
GL.glTranslatef(x,y,0);
|
|
GL.glScalef(sx,sy,1);
|
|
|
|
float xp = 0;
|
|
float yp = 0;
|
|
|
|
for (int tx=0;tx<xcount;tx++) {
|
|
yp = 0;
|
|
for (int ty=0;ty<ycount;ty++) {
|
|
Image image = images[tx][ty];
|
|
|
|
image.drawFlash(xp,yp,image.getWidth(), image.getHeight());
|
|
|
|
yp += image.getHeight();
|
|
if (ty == ycount - 1) {
|
|
xp += image.getWidth();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
GL.glScalef(1.0f/sx,1.0f/sy,1);
|
|
GL.glTranslatef(-x,-y,0);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawFlash(float, float)
|
|
*/
|
|
public void drawFlash(float x, float y) {
|
|
drawFlash(x,y,width,height);
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#endUse()
|
|
*/
|
|
public void endUse() {
|
|
if (lastBind != null) {
|
|
lastBind.endUse();
|
|
}
|
|
lastBind = null;
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#startUse()
|
|
*/
|
|
public void startUse() {
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#ensureInverted()
|
|
*/
|
|
public void ensureInverted() {
|
|
throw new OperationNotSupportedException("Doesn't make sense for tiled operations");
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#getColor(int, int)
|
|
*/
|
|
public Color getColor(int x, int y) {
|
|
throw new OperationNotSupportedException("Can't use big images as buffers");
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#getFlippedCopy(boolean, boolean)
|
|
*/
|
|
public Image getFlippedCopy(boolean flipHorizontal, boolean flipVertical) {
|
|
BigImage image = new BigImage();
|
|
|
|
image.images = images;
|
|
image.xcount = xcount;
|
|
image.ycount = ycount;
|
|
image.width = width;
|
|
image.height = height;
|
|
image.realWidth = realWidth;
|
|
image.realHeight = realHeight;
|
|
|
|
if (flipHorizontal) {
|
|
Image[][] images = image.images;
|
|
image.images = new Image[xcount][ycount];
|
|
|
|
for (int x=0;x<xcount;x++) {
|
|
for (int y=0;y<ycount;y++) {
|
|
image.images[x][y] = images[xcount-1-x][y].getFlippedCopy(true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flipVertical) {
|
|
Image[][] images = image.images;
|
|
image.images = new Image[xcount][ycount];
|
|
|
|
for (int x=0;x<xcount;x++) {
|
|
for (int y=0;y<ycount;y++) {
|
|
image.images[x][y] = images[x][ycount-1-y].getFlippedCopy(false, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#getGraphics()
|
|
*/
|
|
public Graphics getGraphics() throws SlickException {
|
|
throw new OperationNotSupportedException("Can't use big images as offscreen buffers");
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#getScaledCopy(float)
|
|
*/
|
|
public Image getScaledCopy(float scale) {
|
|
return getScaledCopy((int) (scale * width), (int) (scale * height));
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#getScaledCopy(int, int)
|
|
*/
|
|
public Image getScaledCopy(int width, int height) {
|
|
BigImage image = new BigImage();
|
|
|
|
image.images = images;
|
|
image.xcount = xcount;
|
|
image.ycount = ycount;
|
|
image.width = width;
|
|
image.height = height;
|
|
image.realWidth = realWidth;
|
|
image.realHeight = realHeight;
|
|
|
|
return image;
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#getSubImage(int, int, int, int)
|
|
*/
|
|
public Image getSubImage(int x, int y, int width, int height) {
|
|
BigImage image = new BigImage();
|
|
|
|
image.width = width;
|
|
image.height = height;
|
|
image.realWidth = width;
|
|
image.realHeight = height;
|
|
image.images = new Image[this.xcount][this.ycount];
|
|
|
|
float xp = 0;
|
|
float yp = 0;
|
|
int x2 = x+width;
|
|
int y2 = y+height;
|
|
|
|
int startx = 0;
|
|
int starty = 0;
|
|
boolean foundStart = false;
|
|
|
|
for (int xt=0;xt<xcount;xt++) {
|
|
yp = 0;
|
|
starty = 0;
|
|
foundStart = false;
|
|
for (int yt=0;yt<ycount;yt++) {
|
|
Image current = images[xt][yt];
|
|
|
|
int xp2 = (int) (xp + current.getWidth());
|
|
int yp2 = (int) (yp + current.getHeight());
|
|
|
|
// if the top corner of the subimage is inside the area
|
|
// we want or the bottom corrent of the image is, then consider using the
|
|
// image
|
|
|
|
// this image contributes to the sub image we're attempt to retrieve
|
|
int targetX1 = (int) Math.max(x, xp);
|
|
int targetY1 = (int) Math.max(y, yp);
|
|
int targetX2 = Math.min(x2, xp2);
|
|
int targetY2 = Math.min(y2, yp2);
|
|
|
|
int targetWidth = targetX2 - targetX1;
|
|
int targetHeight = targetY2 - targetY1;
|
|
|
|
if ((targetWidth > 0) && (targetHeight > 0)) {
|
|
Image subImage = current.getSubImage((int) (targetX1 - xp), (int) (targetY1 - yp),
|
|
(targetX2 - targetX1),
|
|
(targetY2 - targetY1));
|
|
foundStart = true;
|
|
image.images[startx][starty] = subImage;
|
|
starty++;
|
|
image.ycount = Math.max(image.ycount, starty);
|
|
}
|
|
|
|
yp += current.getHeight();
|
|
if (yt == ycount - 1) {
|
|
xp += current.getWidth();
|
|
}
|
|
}
|
|
if (foundStart) {
|
|
startx++;
|
|
image.xcount++;
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#getTexture()
|
|
*/
|
|
public Texture getTexture() {
|
|
throw new OperationNotSupportedException("Can't use big images as offscreen buffers");
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#initImpl()
|
|
*/
|
|
protected void initImpl() {
|
|
throw new OperationNotSupportedException("Can't use big images as offscreen buffers");
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#reinit()
|
|
*/
|
|
protected void reinit() {
|
|
throw new OperationNotSupportedException("Can't use big images as offscreen buffers");
|
|
}
|
|
|
|
/**
|
|
* Not supported in BigImage
|
|
*
|
|
* @see org.newdawn.slick.Image#setTexture(org.newdawn.slick.opengl.Texture)
|
|
*/
|
|
public void setTexture(Texture texture) {
|
|
throw new OperationNotSupportedException("Can't use big images as offscreen buffers");
|
|
}
|
|
|
|
/**
|
|
* Get a sub-image that builds up this image. Note that the offsets
|
|
* used will depend on the maximum texture size on the OpenGL hardware
|
|
*
|
|
* @param offsetX The x position of the image to return
|
|
* @param offsetY The y position of the image to return
|
|
* @return The image at the specified offset into the big image
|
|
*/
|
|
public Image getSubImage(int offsetX, int offsetY) {
|
|
return images[offsetX][offsetY];
|
|
}
|
|
|
|
/**
|
|
* Get a count of the number images that build this image up horizontally
|
|
*
|
|
* @return The number of sub-images across the big image
|
|
*/
|
|
public int getHorizontalImageCount() {
|
|
return xcount;
|
|
}
|
|
|
|
/**
|
|
* Get a count of the number images that build this image up vertically
|
|
*
|
|
* @return The number of sub-images down the big image
|
|
*/
|
|
public int getVerticalImageCount() {
|
|
return ycount;
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#toString()
|
|
*/
|
|
public String toString() {
|
|
return "[BIG IMAGE]";
|
|
}
|
|
|
|
/**
|
|
* Destroy the image and release any native resources.
|
|
* Calls on a destroyed image have undefined results
|
|
*/
|
|
public void destroy() throws SlickException {
|
|
for (int tx=0;tx<xcount;tx++) {
|
|
for (int ty=0;ty<ycount;ty++) {
|
|
Image image = images[tx][ty];
|
|
image.destroy();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#draw(float, float, float, float, float, float, float, float, org.newdawn.slick.Color)
|
|
*/
|
|
public void draw(float x, float y, float x2, float y2, float srcx,
|
|
float srcy, float srcx2, float srcy2, Color filter) {
|
|
int srcwidth = (int) (srcx2 - srcx);
|
|
int srcheight = (int) (srcy2 - srcy);
|
|
|
|
Image subImage = getSubImage((int) srcx,(int) srcy,srcwidth,srcheight);
|
|
|
|
int width = (int) (x2 - x);
|
|
int height = (int) (y2 - y);
|
|
|
|
subImage.draw(x,y,width,height,filter);
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawCentered(float, float)
|
|
*/
|
|
public void drawCentered(float x, float y) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawEmbedded(float, float, float, float, float, float, float, float, org.newdawn.slick.Color)
|
|
*/
|
|
public void drawEmbedded(float x, float y, float x2, float y2, float srcx,
|
|
float srcy, float srcx2, float srcy2, Color filter) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawEmbedded(float, float, float, float, float, float, float, float)
|
|
*/
|
|
public void drawEmbedded(float x, float y, float x2, float y2, float srcx,
|
|
float srcy, float srcx2, float srcy2) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawFlash(float, float, float, float, org.newdawn.slick.Color)
|
|
*/
|
|
public void drawFlash(float x, float y, float width, float height, Color col) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* @see org.newdawn.slick.Image#drawSheared(float, float, float, float)
|
|
*/
|
|
public void drawSheared(float x, float y, float hshear, float vshear) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|