JanRobertMenzel.de

Forrester Research wirft einen Blick ins Jahr 2016 emnach werden in dem Jahr 375.000.000 Tablets verkauft. Gartner sagt voraus, dass 1/3 aller Tablets iPads sein werden. Soweit plausibel, aber zusätzlich wird Windows 8 eine rosige Zukunft auf Tablets vorausgesagt, ich schätze eher, dass Win8 auf allen Plattformen ein Nischendasein pflegen wird und wie Vista auf PCs erst durch den Nachfolger verdrängt werden kann.

Spannend ist noch folgendes Zitat: “Darüber hinaus prophezeit die Studie das Aufkommen einer neuen Form von Computern, sogenannten “Frames”. Dabei handelt es sich um stationäre Displays, die daran angedockte Tablets vielseitiger nutzbar machen. Solche Geräte werden vor allem in Konferenzräumen, Hotelzimmern und Cafés zur Ausstattung gehören und im Verbund mit Tablets Laptops ersetzen.”

Da setze ich dagegen: Der Vorteil eines Notebooks gegenüber einem Tablet ist die physische Tastatur beim viel tippen sowie stärkere Prozessoren, mehr RAM, vielseitigeres OS und mehr Speicher – der größere Bildschirm ist da nur einer der Unterschiede. Zwar kann man durch das Anschließen eines größeren Monitors oder Beamers mit Tablets auch Präsentationen halten und Filme schauen – dank AirPlay geht das aber heute schon und reicht bei weitem nicht, um Notebooks zu ersetzen. Wir werden künftig öfters mal Tablets als Notebookersatz sehen, an externen “Frames” wird das meiner Meinung aber nicht liegen.

Warten wir ab…

Das Marktforschungsinstitut Gartner sagte 2008 gar das Ende der guten alten Maus voraus. Bei /. wird von “in den nächsten 5 Jahren”, also bis Mitte 2013 gesprochen. Ich setzte dagegen

Auch Computerworld versucht sich in einer Vorhersage, wie sich die Hardware bis 2015 verändern wird. Hier geht es darum, wie Notebooks in 7 Jahren aussehen werden (der Artikel stammt von 2008).

http://www.computerworld.com/s/article/9070158/Hello_gorgeous_Meet_the_laptop_you_ll_use_in_2015?pageNumber=1

Wie bei der GPU Vorhersage bin ich mal gespannt, wie merkwürdig uns das in 6 Jahren anmuten wird.

I played around a bit with Apples OpenCL Hello World example. To test OpenCL with large chunks of data you have to compile it as a 64bit application. But then it crashes because of a bug in the example code:

err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(int), &local, NULL);

This line can’t work in 64 bit mode because sizeof(int) isn’t equal to sizeof(size_t) anymore. But this will do the trick:

err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &local, NULL);

The simple hello world is a bit faster on the GT120 than on the two quad core Xeons running at 2.26GHz. While this is no real world test (not even close) it still once more cool to see what a (not even hi-end) GPU can do.

Running on the CPUs allown, OpenCL can keep 16 cores (hyperthreading) bussy:

OpenCL seems to be much more fun than the old style GPGPU where you tricked OpenGL with shaders and textures into doing math for you

Bereits im Juni war ich auf dem NVidia Round Table Meeting, einem Treffen bei dem Leute zusammenkommen, die mehr mit der GPU machen als nur Grafik für Spiele. GPGPU, Raytracing und Hybridrenderer wurden unter anderem thematisiert. Neben diesen Einblicken, interessanten Gesprächen und Vorträgen zu CUDA und OpenCL gab es natürlich auch die obligatorische Keynote vom Veranstalter mit etwas Selbstbeweihräucherung

Unter anderem gab es von NVidias Marketingchef einen Blick in die Glaskugel. Wie sehen GPUs 2015 aus? Ich will die Punkte hier mal zusammenfassen, damit ich in 6 Jahren mal vergleichen kann, wie gut – oder absurd[1] – Vorhersagen in der IT heute sind.

• Produktion in 11 nm
• ~ 5000 Kerne die auf 3GHz getaktet sind
• ~ 20 TFLOPs Leistung
• ~ 1,2 TB/s Speicherbandbreite
• ~ insgesamt rund die 20-fache Leistung einer aktuellen (sprich: Mitte 2009) GPU

Und das werden wir 2015 mit der Leistung anstellen:

• Hybrides Raytracing/Rasterisieren in Spielen
• Volumenrendering
• Bildschirme mit 4K Auflösung wollen bedient werden, in 120Hz aufgrund echten 3Ds
• Physiksimulationen werden auf der GPU laufen, inklusive Rauch-, Flüssigkeits-, und Kleidungssimulation
• Simulation von Schall
• KI auf der GPU

Na, da dürfen wir gespannt sein wie weit NVidia hier daneben liegt

[1] Wir erinnern uns an Thomas J. Watson von IBM 1943: “I think there is a world market for maybe five computers.”

In der Buchreihe “Graphic Gems” aus den frühen Neunzigern findet sich auch heute noch so mancher interessante und nützliche Artikel. Weniger nützlich, dafür unterhaltsam ist ein Wettbewerb deren Resultate im vierten Buch der Reihe veröffentlicht wurde: Es ging darum, einen möglichst kleinen Raytracer zu schreiben. Klein bedeutet hier, dass der Quellcode aus möglichst wenig Token bestehen sollte (im Gegensatz zur Demoszene, bei denen versucht wird, eine möglichst kleine Executable zu zaubern).

Eine Lösung war klein genug, um sie auf die Rückseite einer Visitenkarte zu drucken:

typedef struct{double x,y,z}vec;vec U,black,amb={.02,.02,.02};struct sphere{
vec cen,color;double rad,kd,ks,kt,kl,ir}*s,*best,sph[]={0.,6.,.5,1.,1.,1.,.9,
.05,.2,.85,0.,1.7,-1.,8.,-.5,1.,.5,.2,1.,.7,.3,0.,.05,1.2,1.,8.,-.5,.1,.8,.8,
1.,.3,.7,0.,0.,1.2,3.,-6.,15.,1.,.8,1.,7.,0.,0.,0.,.6,1.5,-3.,-3.,12.,.8,1.,
1.,5.,0.,0.,0.,.5,1.5,};yx;double u,b,tmin,sqrt(),tan();double vdot(A,B)vec A
,B;{return A.x*B.x+A.y*B.y+A.z*B.z;}vec vcomb(a,A,B)double a;vec A,B;{B.x+=a*
A.x;B.y+=a*A.y;B.z+=a*A.z;return B;}vec vunit(A)vec A;{return vcomb(1./sqrt(
vdot(A,A)),A,black);}struct sphere*intersect(P,D)vec P,D;{best=0;tmin=1e30;s=
sph+5;while(s–>sph)b=vdot(D,U=vcomb(-1.,P,s->cen)),u=b*b-vdot(U,U)+s->rad*s
->rad,u=u>0?sqrt(u):1e31,u=b-u>1e-7?b-u:b+u,tmin=u>=1e-7&&u<tmin?best=s,u:
tmin;return best;}vec trace(level,P,D)vec P,D;{double d,eta,e;vec N,color;
struct sphere*s,*l;if(!level–)return black;if(s=intersect(P,D));else return
amb;color=amb;eta=s->ir;d= -vdot(D,N=vunit(vcomb(-1.,P=vcomb(tmin,D,P),s->cen
)));if(d<0)N=vcomb(-1.,N,black),eta=1/eta,d= -d;l=sph+5;while(l–>sph)if((e=l
->kl*vdot(N,U=vunit(vcomb(-1.,P,l->cen))))>0&&intersect(P,U)==l)color=vcomb(e
,l->color,color);U=s->color;color.x*=U.x;color.y*=U.y;color.z*=U.z;e=1-eta*
eta*(1-d*d);return vcomb(s->kt,e>0?trace(level,P,vcomb(eta,D,vcomb(eta*d-sqrt
(e),N,black))):black,vcomb(s->ks,trace(level,P,vcomb(2*d,N,D)),vcomb(s->kd,
color,vcomb(s->kl,U,black))));}main(){printf(“%d %dn”,32,32);while(yx<32*32)
U.x=yx%32-32/2,U.z=32/2-yx++/32,U.y=32/2/tan(25/114.5915590261),U=vcomb(255.,
trace(3,black,vunit(U)),black),printf(“%.0f %.0f %.0fn”,U);}/*minray!*/

Aber wie das resultierende Bild aus? Im Buch findet sich keine Abbildung. Also schnell den Quellcode ergoogelt (er wird zwar beim Buch mitgeliefert, allerdings nur auf Floppy), ein paar Anpassungen, damit der gcc den Code sauber übersetzt und zu guter letzt noch eben die Ausgabe so abgeändert, dass eine ppm Datei erstellt wird.

Und so sieht das 32*32 Pixel Bildchen dann aus:

Da man heutzutage dem PC etwas mehr Rechenarbeit zumuten darf, hier noch einmal in einer besseren Auflösung:

Geraytraced mit minray aus den Graphics Gems.

Wer selbst einmal mit dem Code spielen will findet ihn übrigens auf der Webseite zum Buch.

Irgendwann hat man mal gelernt, dass .gif Dateien nur 256 Farben darstellen können. Dies stimmt aber nicht ganz, korrekt ist, dass es ein Limit von 256 Farben pro Frame gibt. Aus diesen Frames wird normalerweise eine Animation zusammengestellt. In den 90ern waren diese animierten GIFs besonders beliebt und jede zweite Webseite blinkte, hatte sich drehende new-Buttons und schaufelnde under construction Männchen.

Weniger bekannt ist, dass man diese Frames aber auch nebeneinander platzieren kann und hierdurch beliebig viele verschiedene Farben in ein Bild packen kann. Mit Hilfe der ANGIF Bibliothek kann man das prima selbst ausprobieren.

Sinnvoll nutzen kann man True-Color GIFs trotzdem nicht. Zum einen haben manche Programme ihre Probleme damit mehr als den ersten Frame anzuzeigen, zum zweiten schneiden die Dateien im Größenvergleich nicht gerade optimal ab. Folgendes Bild (512*512 Pixel) belegt als True-Color Gif 1.070 KB:

Read more…

Utah Teapot (Quelle: Wikipedia)

Man kann sich nicht mit Computergrafik beschäftigen, ohne früher oder später über diese Teekanne zu stolpern. Wie kommt es, dass dieses Modell so häufig verwendet wird?

Im Jahr 1975 benötigte der Informatiker Martin Newell ein Modell für seine Forschungen an der Universität von Utah. Er entdeckte die Teekanne seiner Frau und dachte sich: passt. Die Kanne ist leicht nach zu modellieren, hat konkave sowie konvexe Formen und Sattelpunkte an der Tülle. Sie sieht ohne Textur ansprechend aus und wirkt auch spiegelnd oder transparent nicht komisch aus.

Damit eignete sich dieses Modell wunderbar um verschiedene Techniken der Computergrafik auszuprobieren. Das merkten auch die Kollegen, die dankbar das vorhandene Modell aufgriffen.

This teapot article is only available in german, sorry.

Read more…

Man kennt OpenGL als 3D Grafikbibliothek, hieran angelehnt gibt es OpenAL, die Audio Bibliothek und seit kurzem (auf dem Papier) OpenCL.

Viele OpenBuchstabeHierEinfügenL sind allerdings nicht mehr frei, denn vergeben sind schon (manche sogar mehrfach):

• OpenAL
  
• OpenCL
• OpenDL Read more…

Eines der „Standartmodelle“ der Computergrafik ist das Killeroo – halb Velociraptor halb Känguru. Da ich nach all dem Testen von Meshpaint so langsam das Stanford Bunny nicht mehr sehen kann, bin ich auf das Killeroo umgestiegen um die Windows-Portierung meines 3D-Painters mal ausgiebig zu testen.

Killeroo in MeshPaint

Die Textur ist 2048^2 Texel groß und hat zur Zeit 14 Ebenen (dies allein benötigt also 224 MB Grafikkartenspeicher). Es läuft erfreulich schnell und stabil