3d-modelling mit flash actionscript

[scientist]

eure hilfe wäre wirklich sehr hilfreich und ich wäre aufs äußerste dankbar.

zur zeit arbeite ich in meiner ausbildung an einem projekt, in welchem ich innerhalb einer woche einen 3d-quader auf meinem bildschirm via 'actionscript' generieren soll. ich habe aber noch nie mit 'flash' geabreitet (in meinem fall 'mx'). abi hatte ich auch nicht, so daß ich mich gestern schon mal mit dem thema vektoren auseinandergesetzt habe. ich hätte nun folgende fragen:

wie erstelle ich mittels 'actionscript' variable laufzeit-grafiken?
wie kann ich diese transformieren?
ich besitze nur eine profireferenz, in welcher auf die einleitung in die grafische oberfläche von 'flash mx' vollkommen verzichtet wurde.

ich habe kein problem damit mich in dieses thema einzuarbeiten. jedoch fehlt mir der entscheidende ansatz und die zeit. mein projekt soll bis freitag, den 17.10. fertig sein.

Meine ICQ: 212335442

[.:schek]

frag mal den h.storm aus diesem forum hier... der kann das

[bloba]

da hast du ja einen sehr eigenartigen ausbidler der recht komplexe prgrammierung von einem azubi mit tremindruck verlangt..

[Sören]

sorry. Kann es sein, dass die einfach sehen wollen wie "ihr" auf Stress reagiert???

Angenommen ich stell einen Mathestudenten ein, der 1 Semester vor seinem Diplom steht, und ich will ihn testen ob er was drauf hat, dann würde ich ihm folgende Aufgabe stellen:

Erstell innerhalb von 1 Woche einen 3D-Quarder. Die Ansicht soll perspektivisch korrekt sein und komplett in AS programmiert werden.

Dann mal los

[Smirgel]

verschoben

[fresh]

3d- engines gibbet ja jede menge im netz. und die sind wahrscheinlich auch nicht alle komplett "selbst geproggt". solange du die nicht im detail erklären musst, kannst du ja mal die hier nehmen: die engine ist vom saban ünlü, unserem nettrek. der hat aber vergessen, sein copyright reinzuhauen. anpassen musst du dann den bereich ab: hier bitte die objektdaten eingeben

// Hilfsmethoden
// Konstante Rad - dieser Wert wird benötigt um die Winkel von Bogenmaß auf RAD zu berechnen´
Math.RAD = Math.PI/180;
// Sin Funktion für Grad Zahlen
Math.sinD = function(degrees) {
    return Math.sin(degrees*Math.RAD);
};
// Cos Funktion für Grad Zahlen
Math.cosD = function(degrees) {
    return Math.cos(degrees*Math.RAD);
};
// POINT
// Die Point Klasse verwaltet die Punkte im 2D Raum
function Point(x, y) {
    this.x = x == undefined ? 0 : x;
    this.y = y == undefined ? 0 : y;
}
// connectPoints verbindet den Punkt auf dem die Funktion angewandt  wurde
// mit den Punkten die als Parameter (list := Array) übergeben wurden
// targetMC ist die Instanz in der die Verbindung in form von Linien dargestellt werden soll
Point.prototype.connectPoints = function(targetMC, list) {
    var count = list.length;
    targetMC.moveTo(this.x, this.y);
    for (var i = 0; i<count; i++) {
        targetMC.lineTo(list[i].x, list[i].y);
    }
    targetMC.lineTo(this.x, this.y);
};
// Point3D
// Die Point3D Klasse verwaltet die Punkte im 3D Raum
function Point3D(x, y, z) {
    this.x = x == undefined ? 0 : x;
    this.y = y == undefined ? 0 : y;
    this.z = z == undefined ? 0 : z;
}
// move - Verschieb einen Punkt um einen Vektor und gibt einen neuen punkt zurück
Point3D.prototype.moveNew = function(dx, dy, dz) {
    return new Point3D(dx+this.x, dy+this.y, dz+this.z);
};
/* Die Methode getFlashCoord berechnet die 3D Koordinaten mittels Zentralprojektion  in 2D Koordinaten
Für Flash um. Da Flash nicht kartesischen Koordinaten arbeitet wird das Vorzeichen
der Y-Koordinate gewechselt.
viewDistanz ist die Distanz zur Projektionsfläche. Dieser Wert wird benötigt und im Zweifel
Mit dem defaultWert 300 angegebn
Die Methode gibt ein neues Objekt der Klasse Point mit den entsprechenden Koordinaten zurück. */
Point3D.prototype.getFlashCoord = function(viewDistanz) {
    // get Perspective
    viewDistanz = viewDistanz == undefined ? 500 : viewDistanz;
    var div = this.z+viewDistanz;
    // division durch mit null ist nicht möglich
    div = div == 0 ? .0000000001 : div;
    // perspektivenfaktor
    perspective = viewDistanz/div;
    return new Point(this.x*perspective, this.y*-perspective);
};
// Die Methode dient dem Debugging und gibt lediglich die aktuellen Werte eines Punktes zurück.
Point3D.prototype.printPoint3D = function() {
    trace("x:= "+this.x);
    trace("y:= "+this.y);
    trace("z:= "+this.z);
};
// rotX - rotiert den Punkt um die X-Achse. Als Parameter wird der Rotationswinkel
// (degrees) erwartet
Point3D.prototype.rotX = function(degrees) {
    var ca = Math.cosD(degrees);
    var sa = Math.sinD(degrees);
    var tempY = this.y*ca-this.z*sa;
    var tempZ = this.y*sa+this.z*ca;
    this.y = tempY;
    this.z = tempZ;
};
// rotY - rotiert den Punkt um die Y-Achse. Als Parameter wird der Rotationswinkel
// (degrees) erwartet
Point3D.prototype.rotY = function(degrees) {
    var ca = Math.cosD(degrees);
    var sa = Math.sinD(degrees);
    var tempX = this.x*ca+this.z*sa;
    var tempZ = this.z*ca-this.x*sa;
    this.x = tempX;
    this.z = tempZ;
};
// rotY - rotiert den Punkt um die Y-Achse. Als Parameter wird der Rotationswinkel
// (degrees) erwartet
Point3D.prototype.rotZ = function(degrees) {
    var ca = Math.cosD(degrees);
    var sa = Math.sinD(degrees);
    var tempX = this.x*ca-this.y*sa;
    var tempY = this.x*sa+this.y*ca;
    this.x = tempX;
    this.y = tempY;
};
// Klasse Object3d verwaltet ein 3D Objekt
function Object3d() {
    this.areas = new Array();
    this.points = new Array();
}
// Verwaltet einzelne (nicht einer Fläche angehörigen) Punkte der Klasse Point3D
Object3d.prototype.addPoint = function(point) {
    var pos = undefined;
    for (var i in this.points) {
        // kontrolliere ob der Punkt bereits vorhanden ist
        if (this.points[i].x == point.x && this.points[i].y == point.y && this.points[i].z == point.z) {
            pos = i;
        }
    }
    // wenn der Punkt noch nicht vorhanden ist füge ihn hinzu
    if (pos == undefined) {
        this.points.push(point);
        pos = this.points.length-1;
    }
    // gebe den Array Index des Punktes zurück
    return pos;
};
/* addArea verwaltet Flächen eines 3D Objektes und erwartet daher als Parameter eine Liste von
Punkten (der Klasse Point3D) die eine Fläche definieren */
Object3d.prototype.addArea = function() {
    var area = new Array();
    var count = arguments.length;
    for (var i = 0; i<count; i++) {
        var pointIndex = this.addPoint(arguments[i]);
        area.push(pointIndex);
    }
    this.areas.push(area);
};
Object3d.prototype.rot = function(axis, degrees) {
    for (var i in this.points) {
        var currentPoint = this.points[i];
        var fct = "rot"+axis.toUpperCase();
        currentPoint[fct](degrees);
    }
};
// rotX rotiert das gesamte 3D Objekt um die X-Achse bezüglich des angegebenen Rotationswinkels
Object3d.prototype.rotX = function(degrees) {
    this.rot("x", degrees);
};
// rotY rotiert das gesamte 3D Objekt um die Y-Achse bezüglich des angegebenen Rotationswinkels
Object3d.prototype.rotY = function(degrees) {
    this.rot("Y", degrees);
};
Object3d.prototype.rotZ = function(degrees) {
    this.rot("Z", degrees);
};
// Zeichne die Flächen
Object3d.prototype.drawAreas = function(target) {
    for (var i in this.areas) {
        var currentArea = this.areas[i];
        var areaPoints = new Array();
        for (var j in currentArea) {
            var pointIndex = currentArea[j];
            var point = this.points[pointIndex];
            var flashPoint = point.getFlashCoord();
            areaPoints.push(flashPoint);
        }
        var startPoint = areaPoints.shift();
        startPoint.connectPoints(target, areaPoints);
    }
};
this.createEmptyMovieClip("haus", 1);
haus._x = 400;
haus._y = 300;
// hier bitte die Objektdaten eingeben
haus.a = new Point3D(0, 0, -50);
//
haus.b = new Point3D(-100, -100, 50);
haus.c = new Point3D(100, -100, 50);
haus.d = new Point3D(100, 100, 50);
haus.e = new Point3D(-100, 100, 50);
//
haus.a1 = new Point3D(0, 0, -40);
//
haus.b1 = new Point3D(-90, -90, 50);
haus.c1 = new Point3D(90, -90, 50);
haus.d1 = new Point3D(90, 90, 50);
haus.e1 = new Point3D(-90, 90, 50);
//
haus.f = new Point3D(-80, -80, 50);
haus.g = new Point3D(80, -80, 50);
haus.h = new Point3D(80, 80, 50);
haus.i = new Point3D(-80, 80, 50);
//
haus.j = new Point3D(-80, -80, 150);
haus.k = new Point3D(80, -80, 150);
haus.l = new Point3D(80, 80, 150);
haus.m = new Point3D(-80, 80, 150);
//
haus.f1 = new Point3D(-78, -78, 50);
haus.g1 = new Point3D(78, -78, 50);
haus.h1 = new Point3D(78, 78, 50);
haus.i1 = new Point3D(-78, 78, 50);
//
haus.j1 = new Point3D(-78, -78, 150);
haus.k1 = new Point3D(78, -78, 150);
haus.l1 = new Point3D(78, 78, 150);
haus.m1 = new Point3D(-78, 78, 150);
//
haus.cube = new Object3d();
haus.cube.addArea(haus.a, haus.b, haus.c);
haus.cube.addArea(haus.a, haus.c, haus.d);
haus.cube.addArea(haus.a, haus.d, haus.e);
haus.cube.addArea(haus.a, haus.e, haus.b);
haus.cube.addArea(haus.a1, haus.b1, haus.c1);
haus.cube.addArea(haus.a1, haus.c1, haus.d1);
haus.cube.addArea(haus.a1, haus.d1, haus.e1);
haus.cube.addArea(haus.a1, haus.e1, haus.b1);
haus.cube.addArea(haus.f, haus.g, haus.k, haus.j);
haus.cube.addArea(haus.h, haus.g, haus.k, haus.l);
haus.cube.addArea(haus.h, haus.i, haus.m, haus.l);
haus.cube.addArea(haus.i, haus.f, haus.j, haus.m);
haus.cube.addArea(haus.f1, haus.g1, haus.k1, haus.j1);
haus.cube.addArea(haus.h1, haus.g1, haus.k1, haus.l1);
haus.cube.addArea(haus.h1, haus.i1, haus.m1, haus.l1);
haus.cube.addArea(haus.i1, haus.f1, haus.j1, haus.m1);
// Rotationswinkel
haus.degrees = 5;
this.haus.onEnterFrame = function() {
    if (Key.isDown(Key.UP)) {
        this.cube.rotX(this.degrees);
    }
    if (Key.isDown(Key.DOWN)) {
        this.cube.rotX(-this.degrees);
    }
    if (Key.isDown(Key.RIGHT)) {
        this.cube.rotY(this.degrees);
    }
    if (Key.isDown(Key.LEFT)) {
        this.cube.rotY(-this.degrees);
    }
    if (Key.isDown(Key.PGUP)) {
        this.cube.rotZ(this.degrees);
    }
    if (Key.isDown(Key.PGDN)) {
        this.cube.rotZ(-this.degrees);
    }
    this.clear();
    this.lineStyle(.25);
    this.cube.drawAreas(this);
};