# Kugel



## InselBesucher (22. Feb 2010)

Hallo,
Mein IST-Zustand erzeugt z.zt. mehrere 'Bälle' der Klasse JComponente, in der die paintComponent() ueberschireben ist. Der 'Ball' wird derzeitig durch Anreihung mehrerer nach innen verlaufenden g.drawOval erzeugt, welche vond der StartFarbe nach innen heller werden (für die Plastizität). 
	
	
	
	





```
@Override
public void paintComponent(final Graphics g) {
	g.setColor(this.color);
	for (int i = 0; i < this.diameter/ 2; i += 2) {
		g.setColor(new Color((this.color.getRed() + 2 * i) > 255 ? 255 : (this.color.getRed() + 2 * i),
			(this.color.getGreen() + 2 * i) > 255 ? 255 : (this.color.getGreen() + 2 * i), 
			(this.color.getBlue() + 2  * i) > 255 ? 255 : (this.color.getBlue()  + 2 * i))
		);
		g.fillOval(	(0) + i,(0) + i, this.diameter - i*2, this.diameter - i*2 );
	}
	this.setBounds(this.x - this.diameter / 2, this.y - this.diameter / 2, this.diameter, this.diameter);
}
```
Die Bälle werden ausschliesslich im 2D raum betrachtet

Funktionen für den Ball: moveBall(), scaleBall(), rotateBall(), changeColor()

Problem ist, dass die for-Schleife in der paintComponent() sehr teuer ist, und ich bei der scaleBall() sehr viel CPU nutzte. 
Die Rotation  eines Balles weis ich nicht anders zu visualisieren, als einen Punkt auf den Ball zu setzten. Damit ich hier an CPU spare lass ich nun nur den Punkt rotieren. (also nutzte deswegen nicht die g2d.rotate)

Die Frage wäre nun, wie kann ich eine Kugel besser in einen  zweiDimensionalen raum darstellen.
Und eine derzeit noch nicht so wichtige Frage (hab mich auch noch nicht schlau gemacht) wie koennte mit einen Slider die Farbe 'drehen' da ich dort die Farbtemperatur bestimmen moechte.

Meine Ideen zur Visualisierung gingen natürlich in die Richtung Java 2D | 3D. Trotz 2D darstellung dachte ich mir, wäre es vieleicht gut 3D zu nutzen, da im besten fall die Berechnung über die Graphikkarten Logic (z.B. shader) läuft, wenn das Java so handhabt. Dann koennte man denn Ball einfach die Z-Achse verschieben um zu scalieren.
Dann würde man bestimmt am billigsten die Textur drehen, wobei ich nicht weis ob man deren Farbe dann auch frei definierne kann (vieleicht JavaImage).

Vieleicht weis auch jemand wie ich einen Rotierenden Ball (mit einer Farbe, Farbverlauf in die mitte hin) besser darstellen kann.

Bitte schreibt mir Ideen, Lösungsansätze oder Lösungen. 

danke und lieben Gruss


----------



## lumo (22. Feb 2010)

wie wärs mit einem bild von einer kugel? und dann nicht die 2d-funktion nutzen um den gradienten der kugel zu zeichen. sondern du musst nur noch das bild kopieren, wo's hingehört...

oder... opengl  da kannst du mit leichtigkeit kugeln erstellen.
mit 3d-apis, die hardware unterstützen kommt man da viel weiter, hab damit auf der PSP (PlayStation Portable) meshes mit zig tausenden polygonen dargestellt... (allerdings hat das teil kein OpenGL sondern ne custom SCEGU)


----------



## Quaxli (22. Feb 2010)

Zumindest würde ich die Kugel nicht von JComponent erben lassen. Damit schleppst Du ja zuviel unnötigen Kram mit Dir rum. 
Hier mal ein Beispiel ohne JComponent:


```
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;

import javax.swing.*;

public class Display extends JPanel implements Runnable{

	private static final long	serialVersionUID	= 1L;
	JFrame frame;
	Sphere sphere;
	
	public static void main(String[] args) {
	  new Display();
	}
	
	public Display(){
		frame = new JFrame("Beispiel");
		frame.setSize(800,600);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.add(this);
		frame.setVisible(true);
		
		sphere = new Sphere(200,200,50,50);
		
		Thread th = new Thread(this);
		th.start();
	}

	public void paintComponent(Graphics g){
		super.paintComponent(g);
		sphere.drawBall(g);
	}

	public void run() {

		while(frame.isVisible()){
			
			
			repaint();
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
	}
	
}

class Sphere extends Rectangle{
	
	private static final long	serialVersionUID	= 1L;
	int rs = 100;
	int gs = 100;
	int bs = 100;
	
	public Sphere(int bx, int by, int bw, int bh){
		super(bx,by,bw,bh);
		System.out.println(width);
	}
	
	public void drawBall(Graphics g){
		
		Graphics2D g2 = (Graphics2D)g;
		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		
		rs = 100;
		
		for(int realw=width;realw>1;realw-=2){
			rs+=5;
			g2.setColor(new Color(rs,gs,bs));
			g2.drawOval(x+(x-realw)/2, y+(y-realw)/2, realw, realw);
		}
	}
	
	
	
	
}
```


----------



## 0x7F800000 (22. Feb 2010)

Es geht doch um Billard oder sowas?

Ein paar Tipps:
- RadialGradientPaint (Java Platform SE 6) wird wohl schneller gehen, als zig millionen kreise zu zeichnen....
- Color (Java 2 Platform SE v1.4.2) achte auf das vierte Argument: man kann auch halb-durchsichtiges zeugs malen!

Ich würde so vorgehen:
- Halbtransparenten Grau-schwarzen Schatten malen (versetztes gedrehtes Oval)
- Bunte grundierung malen (einfach ein kreis aus gleichmäßigen satten farbe)
- In der zweiten schicht graue "1-Punkt-defekte", die in Polarkoordinaten abgespeichert werden, und mit dem ball mitrotieren Das ins 2D zu projizieren ist billig...
- Darüber eine halb-transparente Schicht mit den spiegelungen/schatten. nicht zentriert, sondern etwas schräg, und am besten in die Richtung der Lichtquelle gedreht. evtl. auch mit mehreren Lichtquellen (zB. eine große weiße quelle, und dann zwei kleinere blau/gelbe oder so).

So kriegt man Kugeln mit leicht austauschbaren Farben, akzeptablen Reflexionen und dank der "1-Punkt-defekte" auch eine gute Illusion, dass die Kugel rollt.


----------



## InselBesucher (22. Feb 2010)

Vielen dank,

sag mal 0x7F800000, kannst du mir dazu einen (sudo)code zeigen. bin sehr ungeschikt bezogen auf Graphics....
lieben dank

me


----------



## 0x7F800000 (23. Feb 2010)

was meist du mit "sudocode"?
Ist meine Prosa-Beschreibung irgendwie zu schwammig geworden?

Den ganzen Code will ich gerade nicht schreiben: wenn ich damit anfange, dann höre ich damit frühestens auf, wenn ich eine multiplayer-version mit einem map-editor für alle möglichen billard-golf-pinball-ähnlichen herausforderungen erstellt habe, und dazu habe ich grade leider weder zeit noch energie...


----------



## Landei (23. Feb 2010)

Nichtlineare Gradient-Beispiele sollten sich auf Filthy Rich Clients finden.


----------



## InselBesucher (23. Feb 2010)

also so richtig weis ich immer noch nicht weiter.

- Wird java2D auch ueber die grafikkarte verarbeitet oder nur 3D? 

- Ggibt es denn schon irgendwo eine Lösung, wir ich billig eine ansehnliche Kugel im 2D raum visualisieren kann und diese bestenfalls rotationen darstellt und ein Color zugewiesen bekommen kann?


----------



## lumo (23. Feb 2010)

was ist mit nem greyscale image, das du per filter mit einer farbe veränderst?
ich nehme mal an dass sich die farbe einer kugel nicht ständig verändert...
sondern dass das bild einmal generiert wird...


----------



## masta // thomas (24. Feb 2010)

InselBesucher hat gesagt.:


> bin sehr ungeschikt bezogen auf Graphics....



Vielleicht wäre es dann sinnvoll, das ganze Framework gestützt anzugehen? (z.B. Interactive Pulp - PulpCore)


----------

