Object.cpp

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#include "Object.h"
#include "Window.h"
#include "TextureManager.h"
#include "Opengl.h"
#include "Configuration.h"

//Zum Verzeichnis einlesen...
#include <sys/types.h>
#include <dirent.h>

//Klassenvariable initialisieren und Speicherplatz reservieren:
Object::classWindowEditAttributes * Object::editAttributes=0;

double Object::getRadiusModified(double r) {
    //Radius reduzieren und linear skalieren
    return pow(r, 1.0/sqrt(double(ourConfiguration.radiusAdaption))) *
           sqr(ourConfiguration.radiusAdaption) *
           ourConfiguration.linearScaleFactor;
}

Vector Object::getDistanceModified(Vector pos) {
    //gegenwaertig nur linear skalieren
    return pos * ( ourConfiguration.linearScaleFactor );
}

Vector Object::getScaledPos() {
    return getDistanceModified(pos);
}

Vector Object::getScaledV() {
    return getDistanceModified(v);
}

double Object::getScaledRadius() {
    return getRadiusModified(radius);
}

void Object::deleteAdditionalInformation(void * additionalInformation) {}

void Object::setName(const string & s) {
    //kopiere den String in das char array.
    const char * newstring = s.c_str();
    if(s.length() == 0)
        newstring= getType();
    strncpy(name,newstring,MAX_NAME_LENGTH);
    name[MAX_NAME_LENGTH] = 0;
}

void Object::load(istream & FILE) {
    int option_=0;
    string s;
    //Suche Anfang der Objektbeschreibung:
    while (! FILE.fail() ) {
        FILE >> s;
        if(s == "!!BEGINBASISOBJECT!!")
            break;
    }
    if(s != "!!BEGINBASISOBJECT!!")
        cerr << "WARNING OBJECT MARK NOT FOUND!" << endl;

    while (! FILE.fail() ) {
        //Lies Attributnummer ein und name (wird nicht beachtet)
        FILE >> option_ >> s;
        switch(option_) {
        case 0:
            FILE >> radius;
            break;
        case 1:
            FILE >>  mass;
            break;
        case 2:
            FILE >>  v;
            break;
        case 3:
            FILE >>  pos;
            break;
        case 4:
            FILE >> s;
            setName(s);
            break;
        case 5:
            FILE >> s;
            setTexture(s);
            break;
        case 1000: //alle Optionen wurden eingelesen !
            return;
        default:
            cerr << "WARNING read unknown option " << option_ << " "
            << s << endl;
        }
    }
}

void Object::save(ostream & FILE) {
    //Speichere alle Attribute in die Datei:
    FILE << getType() <<  endl;
    FILE << "!!BEGINBASISOBJECT!!" << endl;
    FILE << "0 radius: " << radius <<  endl;
    FILE << "1 mass: " << mass <<  endl;
    FILE << "2 v: " << v <<  endl;
    FILE << "3 pos: " << pos <<  endl;
    FILE << "4 name: " << getName() << endl;
    FILE << "5 texture: " << getTexture() << endl;
    FILE << "1000 !!ENDBASISOBJECT!!" << endl;
}


void Object::drawEnd() {

    if( ( ourConfiguration.constructMode ||  ourConfiguration.viewVectors)
            && v.length() != 0) {
        // Zeichne den Geschwindigkeitsvektor
        // Farbe des Vektors ist Pink (wenn lichteffekte aus sind)
        // und sonst weiss.
        glColor3f(1, 0, 1);

        Vector posS = getScaledPos();
        Vector vstart_(posS.x,posS.y,posS.z);
        Vector v=getScaledV();

        //Endpunkt des Vektors ermitteln
        Vector vend_=vstart_+ getDistanceModified(v *
                     ourConfiguration.getTime()) + v.getNormalised()*
                     getScaledRadius();

        //Zeichnen des Vektors:
        glBegin(GL_LINES);
        glVertex3f(vstart_.x,vstart_.y,vstart_.z);
        glVertex3f(vend_.x,vend_.y,vend_.z);
        glEnd();
    }
    //Name des Objekts entfernen.
    glPopName();
}

Object::Object():pos(0,0,0),v(0,0,0),mass(1),radius(1) {
    texture[0]=0;
}

void Object::setTexture(const string & s) {
    // wenn neue Textur gleich der alten Textur ist, ist nichts zu tun
    if(s == texture)
        return;

    //Alte Textur freigeben
    if(texture[0] != 0 )
        ourTextureManager.freeReference(textureNum);

    strncpy(texture,s.c_str(),MAX_TEXTURE_LENGTH);
    texture[MAX_TEXTURE_LENGTH] = 0;

    //Textur und pfadnahmen ermitteln:
    string texturePlusPath ="textures/";

    //Objekttyp (Sonne, etc.) ist Bestandteil des Pfades
    texturePlusPath += getType();
    texturePlusPath += "/";
    texturePlusPath += texture;
    texturePlusPath += ".png";
    textureNum = ourTextureManager.getTextureNumber(texturePlusPath);
}

void Object::FillTextureSelector() {
    GLUI_Listbox * fileSelector= editAttributes->textureSelector;

    //Texturpfad besteht auch aus objekttyp:
    string d="textures/";
    d+= editAttributes->objectType;

    //oeffnen des Verzeichnisses:
    DIR * dir=opendir(d.c_str());
    if(dir == 0 ) {
        cerr << "WARNUNG: Directory " << d << " does not exist!" << endl;
        return;
    }
    dirent * dentry;
    int textureCount=0;
    while ((dentry=readdir(dir))) {
        if(strlen(dentry->d_name) <= MAX_TEXTURE_LENGTH+4) {
            //Alle vorhandenen texturen im Pfad einlesen und in liste anfuegen:
            string s(dentry->d_name);
            uint pos = s.find(".png");

            if( pos != string::npos ) { //Nur png texturen koennen geladen werden
                dentry->d_name[pos] = 0; // erweiterung .png abschneiden !
                //in liste einfuegen:
                fileSelector->add_item(textureCount++, dentry->d_name );
            }
        } else
            //Dateinamen duerfen nicht zu lange sein
            cerr << "WARNING "<< d  << "/" << dentry->d_name << " name is "
            << dentry->d_reclen << " long => longer than "
            << MAX_TEXTURE_LENGTH << " chars" << endl;
    }
    closedir(dir);
}

void Object::closeAttributeWindow() {
    if(editAttributes == 0)
        return;

    //Speichern der objekt einstellungen
    editAttributes->my->saveAttributes();

    //attribut fenster schliessen
    editAttributes->attributeWindow->close();
    if(editAttributes->additionalInformation != 0)
        //Fenster destruktur des tatsaechlichen Objekts aufrufen, damit zusatz
        // information freigegeben werden kann
        editAttributes->my->deleteAdditionalInformation(
            editAttributes->additionalInformation);
    //freigabe des speichers fuer die fuers Fenster benoetigte Informationen
    delete(editAttributes);
    //Anzeigen das das Fenster geschlossen ist:
    editAttributes = 0;
}

void Object::loadAttributes() {
    //Namen fuers Fenster kopieren:
    strcpy(editAttributes->name,name);

    //Texturauswahlliste auf aktuelle Textur festlegen:
    GLUI_Listbox * ts = editAttributes->textureSelector;
    GLUI_Listbox_Item * it = ts->get_item_ptr(texture);
    if(it == NULL) {
        cerr << "WARNING: texture " << texture
        << " does not exist for object " <<
        editAttributes->objectType << " !" << endl;
    } else
        ts->do_selection(it->id);

}

void Object::saveAttributes() {
    //Falls sich der Name geandert hat diesen speichern und
    //die Objektauswahlliste anpassen:
    if( strcmp(editAttributes->name, getName())) {
        setName(editAttributes->name);
        Window::reloadObjectSelector();
    }

    //Speichern der Textur
    setTexture((char *)editAttributes->textureSelector->curr_text);
}

void Object::createAttributeWindow() {
    if(editAttributes != 0 && editAttributes->my == this )
        return;

    const string & objectType = getType();

    //Altes Fenster schliessen sofern dieses geoeffnet ist
    Object::closeAttributeWindow();
    editAttributes = new classWindowEditAttributes;

    //Fensterposition festlegen:
    //glutInitWindowPosition(0,0);
    //Fenster erzeugen:
    editAttributes->attributeWindow = GLUI_Master.create_glui("Attributes");

    editAttributes->my = this;
    editAttributes->additionalInformation = 0;
    GLUI * aw= editAttributes->attributeWindow;
    editAttributes->objectType = objectType;

    //Kontrollen erzeugen
    aw->add_button( "Close",CANCEL,(GLUI_Update_CB)
                    Object::AttributeMenuCallback);
    aw->add_separator();


    aw->add_edittext("Name", GLUI_EDITTEXT_TEXT,& editAttributes->name);
    GLUI_Panel * pPos=aw->add_panel("pos");
    GLUI_Panel * pV=aw->add_panel("speed v");

    GLUI_Spinner * stmp= aw->add_spinner_to_panel(pPos,"x",
                         GLUI_EDITTEXT_DOUBLE, & this->pos.x);
    //Breite setzen:
    stmp->set_w(200);
    stmp=aw->add_spinner_to_panel(pPos,"y", GLUI_EDITTEXT_DOUBLE, & this->pos.y);
    stmp->set_w(200);
    stmp=aw->add_spinner_to_panel(pPos,"z", GLUI_EDITTEXT_DOUBLE, & this->pos.z);
    stmp->set_w(200);

    stmp=aw->add_spinner_to_panel(pV,"x", GLUI_EDITTEXT_DOUBLE, & this->v.x);
    stmp->set_w(200);
    stmp=aw->add_spinner_to_panel(pV,"y", GLUI_EDITTEXT_DOUBLE, & this->v.y);
    stmp->set_w(200);
    stmp=aw->add_spinner_to_panel(pV,"z", GLUI_EDITTEXT_DOUBLE, & this->v.z);
    stmp->set_w(200);

    stmp=aw->add_spinner("mass", GLUI_EDITTEXT_DOUBLE, & this->mass);
    stmp->set_w(200);
    stmp= aw->add_spinner("radius", GLUI_EDITTEXT_DOUBLE,& this->radius);
    stmp->set_double_limits(1e-100,1e15);
    stmp->set_w(200);

    //Textur Selector erzeugen und fuellen:
    editAttributes->textureSelector = aw->add_listbox("Texture",NULL ,TEXTURE,
                                      (GLUI_Update_CB)
                                      Object::AttributeMenuCallback);
    FillTextureSelector();

    //Hauptfenster aktualisieren wenn eine Live Variable geandert wird:
    aw->set_main_gfx_window(Window::getMainWindow());

    //Attributswerte laden
    refreshAttributes();
}

void Object::AttributeMenuCallback(int b) {
    if(Object::editAttributes == 0) {
        //Hierher sollten wir niemals kommen !
        cerr << "FEHLER Object::editAttributes uninitialisiert";
        return;
    }

    //Welche Kontrolle loesste die Callbackfunktion aus ?
    switch(b) {
    case(TEXTURE): {
            //Speichern des Texturnamens und neuzeichen:
            editAttributes->my->saveAttributes();
            Opengl::redraw();
            break;
        }
    case(CANCEL): {
            //Attributfenster schlie�n
            closeAttributeWindow();
            break;
        }
    default:
        cerr << "UNKNOWN KEY PRESSED " << b << " AttributeMenuCallback" << endl;
    }
}

GLuint Object::getOpenglTextureNumber() {
    return ourTextureManager.getOpenglTexture(textureNum);
}

void Object::drawBegin() {
    // Opengl soll gleichzeitig Zeiger auf Objekt zurueckgeben wenn Objekt
    // angeklickt
    // Verwende die speicherposition als Namen:
    glPushName(reinterpret_cast<uint>(this));
}

---