Sphere und Objekte darauf anordnen

[theforceismine]

Hallo,
ich habe eine Sphere als Weltkugel.. schaut schonmal ganz toll aus. Jetzt möchte ich auf der Weltkugel zu bestimmten Ländern Objekte draufsetzen, also zB. nen Plane an eine bestimmte Position auf der Weltkarte.

Ich hab schon etwas recherchiert und man kann wohl Objekte auf die Vertices der Sphere ausrichten, bei mir funktioniert das allerdings nicht.
Sobald ich die Kugel drehe, ändern sich die Vertices nicht, die blieben immer gleich. Woran könnte das liegen?

Und noch ne Frage:
ich benutze ein MovieAssetMaterial als Textur. Kann ich innerhalb des MovieClips weitere Punkte (auch als MovieClips) anlegen, und dann deren Texturkoordinaten auf die Raumkoordinaten übertragen??
Dann könnte ich z.B. in Deutschland nen Punkt setzen, die Koordinaten auf der Kugel berechnen und dann dort wieder nen 3D-Sprite oder ein Objekt draufsetzen.
Ist sowas überhaupt möglich?

Danke schonmal,
Martin

[Plopsi]

najo ich hab das mit positionen auf ner sphere mit longitude latitude gemacht

//x,y und z position im objectspace: (lat=latitude/lng=longitude)
x = radius * Math.sin(lat) * Math.sin(lng);
y = radius * Math.cos(lat); 
z = radius * Math.sin(lat) * Math.cos(lng); 

packst du nun die sphere und die planes oder was auch immer in einen ObjectContainer3D und drehst den bleiben auch die planes/etc an der richtigen stelle

beachte bitte das deine Textur entsprechend beim nullmeridian anfangen muss also textur X=0 ungefähr bei London - andernfalls muss du den versatz abziehen von ähm.. lng wars

[theforceismine]

hi,
danke für die infos, wo finde ich denn heraus, wie ich aus ner x/y Koordinate die entsprechende Lat/Longitude berechnen kann?

Danke und Gruß

[Plopsi]

ich bin zwar kein mathegenie aber würde mal sagen so:

lng = 360/texturbreite * x - 180
lat = 180/texturhöhe *y - 90

ach noch ne anmerkung, vergesses selbst oft, sin cos etc. verlangen radianten keine gradwerte also:

deg2rad(degAngle :Number):Number{
return ((degAngle * Math.PI) / 180);
} 

alternativ kannste aber auch bei googleearth nachschauen wo ein ort liegt

[theforceismine]

Hi,

danke für die Formeln... nur irgendwie hauts nicht so ganz hin:
Link zum Flash

auf der Erde sind kleine rote Punkte zu sehen. Z.B. bei London. Das sind MovieClips auf meiner Textur. Ich berechne die Längen/Breitengrade dieser MovieClips und übertrage die Position dann auf eine Position im 3D-Raum über diese Funktion:

var l = 360 / w2 * (MovieClip( MovieAssetMaterial( CompositeMaterial(earthNew.material).materials[1] ).movie )["point"+i].y) - 90;
var lo = 180 / h2 * (MovieClip( MovieAssetMaterial( CompositeMaterial(earthNew.material).materials[1] ).movie )["point"+i].x) - 180;	

...

var coords:Number3D = sphericalToCartesian( radius, l, lo );
p.x = coords.x;
p.y = coords.y;
p.z = coords.z;
...

private function sphericalToCartesian (radius:Number, theta:Number, phi:Number):Number3D
{
     var x:Number = radius * Math.cos(theta) * Math.sin(phi);
     var y:Number = radius * Math.sin(theta) * Math.sin(phi);
     var z:Number = radius * Math.cos(phi);
            
     x = radius * Math.sin(theta) * Math.sin(phi);
     y = radius * Math.cos(theta); 
     z = radius * Math.sin(theta) * Math.cos(phi);       		

     return new Number3D(x, y, z);
}

...aber wie man sieht, passen zwar die Abstände der roten Planes verhältnismässig mit denen der Texturpunkte überein, nur die Koordinaten sind falsch.
Woran könnte das liegen?

[Plopsi]

ich glaub du hast l und lo vertauscht

var lo = 360 / w2 * (MovieClip( MovieAssetMaterial( CompositeMaterial(earthNew.material).materials[1] ).movie )["point"+i].y) - 180;
var l = (180 / h2 * (MovieClip( MovieAssetMaterial( CompositeMaterial(earthNew.material).materials[1] ).movie )["point"+i].x) - 90) * -1; 

denk dran das london in der der textur auf X=0 liegen muss

[theforceismine]

Hi,

ich habe jetzt folgenden Code.. rein logisch müsste das alles stimmen, praktisch funktionierts noch nicht ganz:

Diesen kryptischen Code mit der CompositeTextur hab ich jetzt ersetzt, einfach durch den "pointsMc" also den MovieClip, der die roten Punkte enthält.
Außerdem hab ich die Textur so geändet, dass sie bei London beginnt, hab da auch ne rote Linie als Meridian eingebaut.

Die "sphericalToCartesian" Funktion hab ich auch nochmal von ner Formelsammlung aus dem Netz überprüft und zur besseren Verständlichkeit die long und lat Parameter eingebaut. Außerdem hatte ich vergessen die Grad in Rad umzuwandeln.
Es haut jetzt fast hin.. nur irgendwie schauts jetzt so aus, als wären die Punkte von den Koordinaten am Äquator nach unten gespiegelt... zumindest liegen sie schonmal auf den korrekten Längengraden. Also wir sind fast am Ziel!

PHP-Code:

...
var w2:Number = pointsMc.width;
var h2:Number = pointsMc.height;
var radius:Number = SIZE_EARTH_DIAMETER_KM * 0.5;

for (var i:int=1; i<4; i++) 
{
    lat = pointsMc["point"+i].x / w2 * 360 - 180;
    long = pointsMc["point"+i].y / h2 * 180 - 90 * -1;              
        
    var p:Plane = new Plane( planeMat, 5000, 5000, 4, 4 );
    p.useOwnContainer = true;
    view3d.scene.addChild( p );
    planes.push( p );
                 
    var coords:Number3D = sphericalToCartesian( radius, lat, long );
    p.x = coords.x;
    p.y = coords.y;
    p.z = coords.z;
}        

private function sphericalToCartesian( radius:Number, latitude:Number, longitude:Number ):Number3D
{
    latitude = deg2rad( latitude );
    longitude = deg2rad( longitude );
            
    var x:Number = radius * Math.cos(latitude) * Math.cos(longitude);
    var y:Number = radius * Math.cos(latitude) * Math.sin(longitude);
    var z:Number = radius * Math.sin(latitude);
            
    return new Number3D(x, y, z);
}

private function deg2rad( degAngle:Number ):Number 
{
    return ((degAngle * Math.PI) / 180);
} 


hier nochmal der Link, so wie's jetzt ausschaut:
Erde

[Plopsi]

was zu hölle rechnest du denn da probier mal das:

long = (w2/360*pointsMc["point"+i].x - 180);
lat = (h2 / 180 *pointsMc["point"+i].y - 90) * -1; 

ok bei den achsen wiess ich nicht genau aber für away3d siehts so aus:

private function sphericalToCartesian( radius:Number, latitude:Number, longitude:Number ):Number3D
{
    latitude = deg2rad( latitude );
    longitude = deg2rad( longitude );
            
    var x:Number = radius * Math.sin(latitude) * Math.sin(longitude);
var y:Number = radius * Math.cos(latitude);    
var z:Number = radius * Math.sin(latitude) * Math.cos(longitude);
    
            
    return new Number3D(x, y, z);
} 

[theforceismine]

du, meine Formel macht nichts anderes als deine
Rechne mal durch... gibt das gleiche Ergebnis.

Ich habs jetzt gelöst... es funktioniert!!!
So wie oben bereits beschrieben, man muss nur eine Kleinigkeit ändern.
Da das Papervision Koordinatensystem eine umgekehrte Y-Achse hat muss man schreiben:

PHP-Code:

    p.y = -coords.y; 


that's it! Yeah!

[Plopsi]

ah ok

[theforceismine]

ach ich verzweifel noch.. irgendwie funzt das doch nicht so, wie ich mir das vorgestellt hab.

Solange die Punkte noch relativ nahe am Null-Meridian sind, also ca. in der Nähe von London hauts hin.. aber sobald die sich weiterwegbewegen, z.B. Nord- oder Südamerika, dann verschiebts die wieder an andere Stellen, wo sie eigentlich nicht sein dürften.

Ich verstehs nicht... sicher dass die Umwandlung von x/y nach lat/long so passt?

[Plopsi]

öhm ehrlich gesagt nein aber probier doch einfach mal n paar bekannte werte einzugeben:

hier n link zu ner tabelle Tabellen der Astronomie: Geogr.Koordinaten von Städten in aller Welt

[theforceismine]

so.. jetzt passts 1:1.... da war ja alles verdreht - habs gerade herausgefunden, indem ich über den Globus verteilt 4 Punkteachsen angelegt hab und geschaut hab, an welchen Punkten die zusammenlaufen. Und nachdem der Schnittpunkt irgendwo im Pazifik anstatt am Nordpol war, konnte dann doch irgendwas nicht so ganz stimmen.

Ich dokumentiere das jetzt mal, gibt ja bestimmt noch mehr Leute, die so etwas ähnliches bauen möchten - folgendes muss man ändern:

PHP-Code:

var p:Point = new Point( pointsMc["point"+i].x, pointsMc["point"+i].y );
lat = ((p.y / h2 * 180) - 90) * -1;
long = (p.x / w2 * 360);

// "a" ist mein Objekt im 3D-Raum
var coords:Number3D = sphericalToCartesian( radius, lat, long );
a.x = coords.x;
a.y = coords.y;
a.z = coords.z;


....

private function sphericalToCartesian( radius:Number, latitude:Number, longitude:Number ):Number3D
{
     latitude = deg2rad( latitude );
     longitude = deg2rad( longitude );
            
     var x:Number = radius * Math.cos(latitude) * Math.cos(longitude);
     var y:Number = radius * Math.sin(latitude);
     var z:Number = radius * Math.cos(latitude) * Math.sin(longitude);  

     return new Number3D( x, y, z );
} 


... bei der sphericalToCartesian Funktion waren die Berechnungen für y und z-Achse vertauscht, deswegen hats alles verhauen. So wie's oben steht stimmts jetzt für Papervision... bei anderen 3D-Engines kann sich das sicherlich auch ändern, je nach Achsen-Anordnung.


Viele Grüße,
Martin

[Plopsi]

ja dieses achsenvertauschen kenn ich von meinem projekt hat mich fast alle haare gekostet bis ich damals bei away3d drauf gekommen bin