Guest User

BildX

a guest
Feb 2nd, 2017
29
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import ea.*;
  2.  
  3. import ea.internal.collision.Collider;
  4. import ea.internal.io.ImageLoader;
  5.  
  6. import java.awt.*;
  7. import java.awt.geom.Rectangle2D;
  8. import java.awt.image.BufferedImage;
  9.  
  10. /**
  11. * Ein Bild als Grafische Repraesentation einer Bilddatei, die gezeichnet werden kann.
  12. *
  13. * @author Michael Andonie
  14. */
  15. public class BildX extends Raum {
  16. /**
  17. * Die Breite der Quellbilddatei
  18. */
  19. private final int urBreite;
  20.  
  21. /**
  22. * Die Höhe der Quellbilddatei
  23. */
  24. private final int urHoehe;
  25.  
  26. /**
  27. * Die effektive Breite des Bildes auf der Zeichenebene
  28. */
  29. private int breite;
  30.  
  31. /**
  32. * Die effektive Höhe des Bildes auf der Zeichenebene
  33. */
  34. private int hoehe;
  35.  
  36. /**
  37. * Gibt an, ob sich das Bild wiederholen soll.<br /> In diesem Fall wird das Bild in der
  38. * originalen Groesse ueber den Zugesprochenen Grund wiederholt.
  39. */
  40. private boolean wiederholen;
  41.  
  42. /**
  43. * Das BufferedImage, das dieses Bild darstellt.
  44. */
  45. private BufferedImage img;
  46.  
  47. /**
  48. * Minimaler Konstruktor. Erstellt ein neues Bild an der Position (0|0).
  49. *
  50. * @param verzeichnis
  51. * Der Verzeichnispfad des Bildes, das geladen werden soll.
  52. */
  53. public BildX (String verzeichnis) {
  54. this(0, 0, verzeichnis);
  55. }
  56.  
  57. /**
  58. * Der minimale Basiskonstruktor fuer Objekte der Klasse Bild.<br /> Der absolute
  59. * Standartkonstruktor, der bei allen anderen ebenfalss aufgerufen wird. Dieser gleicht die
  60. * Position an und laedt das Bild
  61. *
  62. * @param x
  63. * Die X-Position
  64. * @param y
  65. * Die Y-Position
  66. * @param verzeichnis
  67. * Der Verzeichnispfad des Bildes, das geladen werden soll.
  68. */
  69. public BildX (float x, float y, String verzeichnis) {
  70. this.position = new Punkt(x, y);
  71. this.wiederholen = false;
  72.  
  73. img = ImageLoader.loadExternalImage(verzeichnis);
  74.  
  75. urHoehe = img.getHeight();
  76. urBreite = img.getWidth();
  77. }
  78.  
  79. /**
  80. * Erweiterter Konstruktor.<br /> Hiebei wird ein Bild erstellt, wobei auch dessen Masse
  81. * variabel angegeben werden koennen.
  82. *
  83. * @param x
  84. * Die X-Position
  85. * @param y
  86. * Die Y-Position
  87. * @param breite
  88. * Die Breite, die das Bild haben soll
  89. * @param hoehe
  90. * Die Hoehe, die das Bild haben soll.
  91. * @param verzeichnis
  92. * Der Verzeichnispfad des Bildes, das geladen werden soll.
  93. */
  94. public BildX (float x, float y, int breite, int hoehe, String verzeichnis) {
  95. this(x, y, breite, hoehe, verzeichnis, false);
  96. }
  97.  
  98. /**
  99. * Erweiterter Konstruktor.<br /> Hiebei wird ein Bild erstellt, wobei auch dessen Masse
  100. * variabel angegeben werden koennen.
  101. *
  102. * @param x
  103. * Die X-Position
  104. * @param y
  105. * Die Y-Position
  106. * @param breite
  107. * Die Breite, die das Bild haben soll
  108. * @param hoehe
  109. * Die Hoehe, die das Bild haben soll.
  110. * @param verzeichnis
  111. * Der Verzeichnispfad des Bildes, das geladen werden soll.
  112. * @param wiederholen
  113. * Ob das Bild skaliert oder wiederholt werden soll. <br /> In diesem Fall wird das Bild in
  114. * der originalen Groesse ueber den Zugesprochenen Grund wiederholt: die Parameter
  115. * <code>breite</code> und <code>hoehe</code> beschreiben diesen Flaeche.
  116. */
  117. public BildX (float x, float y, int breite, int hoehe, String verzeichnis, boolean wiederholen) {
  118. this(x, y, verzeichnis);
  119. this.wiederholen = wiederholen;
  120. this.breite = breite;
  121. this.hoehe = hoehe;
  122. this.wiederholen = wiederholen;
  123.  
  124. if (!wiederholen) {
  125. img = resize(img, breite, hoehe);
  126. }
  127. }
  128.  
  129. /**
  130. * Ändert ein BufferedImage von seinen Maßen her.<br /> Wird intern benutzt im Konstruktor.
  131. *
  132. * // TODO: [4.0] Change visibility
  133. *
  134. * @param img
  135. * Das zu beschraenkende Bild
  136. * @param width
  137. * Die neue Breite des Bildes
  138. * @param height
  139. * Die neue Hoehe des Bildes
  140. */
  141. public static BufferedImage resize (BufferedImage img, int width, int height) {
  142. GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
  143. GraphicsConfiguration gc = env.getDefaultScreenDevice().getDefaultConfiguration();
  144.  
  145. BufferedImage resize = gc.createCompatibleImage(img.getWidth(), img.getHeight(), img.getTransparency());
  146. Graphics2D g = resize.createGraphics();
  147.  
  148. g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  149. g.drawImage(img, 0, 0, width, height, 0, 0, img.getWidth(), img.getHeight(), null);
  150. g.dispose();
  151.  
  152. return resize;
  153. }
  154.  
  155. /**
  156. * Erstellt ein Bild, unter Eingabe dessen effektiver Größe als prozentualer Anteil an der der
  157. * Bilddatei.
  158. *
  159. * @param x
  160. * Die X-Position
  161. * @param y
  162. * Die Y-Position
  163. * @param prozent
  164. * Der prozentuale Anteil, den das Bild im Vergleich zu der urspruenglichen Bilddatei haben
  165. * soll
  166. * @param verzeichnis
  167. * Der Verzeichnispfad des Bildes, das geladen werden soll.
  168. */
  169. public BildX (float x, float y, int prozent, String verzeichnis) {
  170. this(x, y, verzeichnis);
  171.  
  172. img = resize(img, img.getWidth() * prozent / 100, (img.getHeight() * prozent) / 100);
  173. }
  174.  
  175. /**
  176. * Direkter Konstruktor.<br /> Dieser erwartet direkt die Bilddatei, die es anzuzeigen gilt.<br
  177. * /> Dieser Konstruktor wird innerhalb der Engine verwendet fuer die Maus.
  178. */
  179. public BildX (float x, float y, BufferedImage img) {
  180. this.img = img;
  181.  
  182. this.positionSetzen(new Punkt(x, y));
  183.  
  184. urHoehe = img.getHeight();
  185. urBreite = img.getWidth();
  186.  
  187. hoehe = urHoehe;
  188. breite = urBreite;
  189. }
  190.  
  191. /**
  192. * Rotiert das Objekt um eine bereits definierte Rotation.
  193. *
  194. * TODO: Unterschied zu #drehen erklären
  195. * FIXME: Es wird keine neue Breite gesetzt, aber die Breite verändert sich, falls nicht um 90 * n Grad gedreht wird
  196. *
  197. * @param rot
  198. * Das Rotationsobjekt, das die Rotation beschreibt
  199. *
  200. * @see Rotation
  201. */
  202. public void rotieren (Rotation rot) {
  203. img = rotieren(img, rot.winkelBogen());
  204. }
  205.  
  206. /**
  207. * Rotiert ein BufferedImage und gibt das neue, rotierte Bild aus.
  208. * <p/>
  209. * Es wird immer nur um die eigene Mitte gedreht!!
  210. *
  211. * @param img
  212. * Das zu rotierende Bild
  213. * @param angle
  214. * Der Winkel im Bogenmass, um den gedreht werden soll.
  215. */
  216. public static BufferedImage rotieren (BufferedImage img, double angle) {
  217. int w = img.getWidth();
  218. int h = img.getHeight();
  219.  
  220. BufferedImage dimg = new BufferedImage((int) (w * Math.sin(angle) + w * Math.cos(angle)), (int) (h * Math.sin(angle) + h * Math.cos(angle)), img.getType());
  221.  
  222. Graphics2D g = dimg.createGraphics();
  223. g.rotate(angle, w / 2, h / 2);
  224. g.drawImage(img, null, (int) (Math.cos(angle) * h / 2 * Math.sin(angle)), (int) (Math.cos(angle) * h / 2 * Math.sin(angle)));
  225.  
  226. g.dispose();
  227.  
  228. return dimg;
  229. }
  230.  
  231. /**
  232. * Zeichnet das Objekt.
  233. *
  234. * @param g
  235. * Das zeichnende Graphics-Objekt
  236. * @param r
  237. * Das BoundingRechteck, dass die Kameraperspektive Repraesentiert.<br /> Hierbei soll
  238. * zunaechst getestet werden, ob das Objekt innerhalb der Kamera liegt, und erst dann
  239. * gezeichnet werden.
  240. */
  241. public void zeichnen (Graphics2D g, BoundingRechteck r) {
  242. if (r.schneidetBasic(this.dimension())) {
  243. super.beforeRender(g, r);
  244.  
  245. if (!wiederholen) {
  246. g.drawImage(img, (int) (position.realX() - r.x), (int) (position.realY() - r.y), null);
  247. } else {
  248. // Texturfarbe erstellen, Anchor-Rechteck hat genau die Bildmaße
  249. Paint tp = new TexturePaint(img, new Rectangle2D.Double(-r.x + position.realX(), -r.y + position.realY(), img.getWidth(), img.getHeight()));
  250. // Texturfarbe setzen
  251. g.setPaint(tp);
  252. // Rechteck füllen
  253. g.fill(new Rectangle2D.Double(position.realX() - r.x, position.realY() - r.y, breite, hoehe));
  254. }
  255.  
  256. super.afterRender(g, r);
  257. }
  258. }
  259.  
  260. /**
  261. * @return Ein BoundingRechteck mit minimal nötigem Umfang, um das Objekt <b>voll
  262. * einzuschließen</b>.
  263. */
  264. public BoundingRechteck dimension () {
  265. if (!wiederholen) {
  266. return new BoundingRechteck(position.realX(), position.realY(), img.getWidth(), img.getHeight());
  267. } else {
  268. return new BoundingRechteck(position.realX(), position.realY(), breite, hoehe);
  269. }
  270. }
  271.  
  272. /**
  273. * {@inheritDoc} Collider wird direkt aus dem das <code>Raum</code>-Objekt umfassenden
  274. * <code>BoundingRechteck</code> erzeugt, dass über die <code>dimension()</code>-Methode
  275. * berechnet wird.
  276. */
  277. @Override
  278. public Collider erzeugeCollider () {
  279. return erzeugeLazyCollider();
  280. }
  281.  
  282. /**
  283. * Gibt die Breite der Bilddatei, aus der dieses Bild besteht, in Pixeln zurueck.
  284. *
  285. * @return Die Breite der urspruenglichen Bilddatei in Pixeln
  286. */
  287. public int normaleBreite () {
  288. return urBreite;
  289. }
  290.  
  291. /**
  292. * Gibt die Hoehe der Bilddatei, aus der dieses Bild besteht, in Pixeln zurueck.
  293. *
  294. * @return Die Hoehe der urspruenglichen Bilddatei in Pixeln
  295. */
  296. public int normaleHoehe () {
  297. return urHoehe;
  298. }
  299.  
  300. /**
  301. * Gibt das Bild als <code>BufferedImage</code> zurueck.<br /> Dies ist eine
  302. * JAVA-Standartklasse.
  303. *
  304. * @return Das Bild als <code>BufferedImage</code>.
  305. */
  306. public BufferedImage bild () {
  307. return this.img;
  308. }
  309.  
  310. public void setBild(BufferedImage pImg) {
  311. this.img = pImg;
  312. }
  313.  
  314. public final Bild clone () {
  315. return new Bild(positionX(), positionY(), img);
  316. }
  317. }
RAW Paste Data