Hallo, ich habe dieses SpaceInvaders Tutorial gemacht. Dort wird der Bildladeprozess optimiert, in dem man zuerst native Einstellungen dazu verwendet (irgendwie so habe ich es verstanden).
Vorher
Nachher
Nun ist das ganze jedoch nicht schneller, sondern beginnt stark zu ruckeln. Woran liegt das?
Eine weitere Frage:
Was ist performanter? Entweder man zeichnet immer alles auf einem Canvas Objekt, oder man verwendet Komponenten, die man dann bewegt? Wahrscheinlich wird beides dasselbe sein, oder nicht? Weil Java muss ja dann auch alles neu zeichnen, wenn man Komponenten verwendet.
Vorher
Code:
public class SpriteCache extends ResourceCache{
protected Object loadResource(URL url) {
try {
return ImageIO.read(url);
} catch (Exception e) {
System.out.println("No se pudo cargar la imagen de "+url);
System.out.println("El error fue : "+e.getClass().getName()+" "+e.getMessage());
System.exit(0);
return null;
}
}
public BufferedImage getSprite(String name) {
return (BufferedImage)getResource(name);
}
}
public abstract class ResourceCache
{
protected HashMap<String, Object> resources;
public ResourceCache()
{
resources = new HashMap<String, Object>();
}
/**
* Loads a resource from the classpath
*
* @param name
* @return
*/
protected Object loadResource(String name)
{
URL url = null;
url = getClass().getClassLoader().getResource(name);
return loadResource(url);
}
/**
*
* @param name
* @return Resource as Object
*/
protected Object getResource(String name)
{
Object res = resources.get(name);
//Check if object has been loaded
if(res == null)
{
res = loadResource("res/" + name);
resources.put(name, res);
}
return res;
}
protected abstract Object loadResource(URL url);
}
Nachher
Code:
public class SpriteCache extends ResourceCache implements ImageObserver
{
BufferedImage compatible;
protected Object loadResource(URL url) {
try {
return ImageIO.read(url);
} catch (Exception e) {
System.out.println("No se pudo cargar la imagen de "+url);
System.out.println("El error fue : "+e.getClass().getName()+" "+e.getMessage());
System.exit(0);
return null;
}
}
public BufferedImage createCompatible(int width, int height, int transparency) {
GraphicsConfiguration gc =
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
BufferedImage compatible = gc.createCompatibleImage(width,height,transparency);
return compatible;
}
public BufferedImage getSprite(String name) {
BufferedImage loaded = (BufferedImage)getResource(name);
if(compatible == null)
{
compatible = createCompatible(loaded.getWidth(),loaded.getHeight(),Transparency.BITMASK);
}
Graphics g = compatible.getGraphics();
g.drawImage(loaded,0,0,this);
return compatible;
}
public boolean imageUpdate(Image img, int infoflags,int x, int y, int w, int h) {
return (infoflags & (ALLBITS|ABORT)) == 0;
}
}
public abstract class ResourceCache {
protected HashMap resources;
public ResourceCache() {
resources = new HashMap();
}
protected Object loadResource(String name) {
URL url=null;
url = getClass().getClassLoader().getResource(name);
return loadResource(url);
}
protected Object getResource(String name) {
Object res = resources.get(name);
if (res == null) {
res = loadResource("res/"+name);
resources.put(name,res);
}
return res;
}
protected abstract Object loadResource(URL url);
}
Nun ist das ganze jedoch nicht schneller, sondern beginnt stark zu ruckeln. Woran liegt das?
Eine weitere Frage:
Was ist performanter? Entweder man zeichnet immer alles auf einem Canvas Objekt, oder man verwendet Komponenten, die man dann bewegt? Wahrscheinlich wird beides dasselbe sein, oder nicht? Weil Java muss ja dann auch alles neu zeichnen, wenn man Komponenten verwendet.