Ich weiß nicht so genau, ob das hier hin gehört, aber es geht um die von WorldCraft erzeugten *.map Dateien. In dieser Datei ist ja ein HL-Level mitsamt der Entities (Lichter usw..) gespeichert.

Nun hab ich ne eigene Engine geschrieben, kann aber keine Levels machen, so hab ich mir gedacht, ich benutze WorldCraft dafür. Aber diese *.map Files sehen auf dem ersten Blick logisch aufgebaut aus, aber auf dem zweiten sieht es schier unmöglich aus, daraus irgendwelche Triangle-Daten ( 3 Punkte: Va,Vb,Vc (x,y,z,u,v) und Textur) zu extrahieren!

Kennt ihr irgenwelche programme, die diese Daten z.B. in das *.ase Format o.ä. umwandeln? Bitte helft mir, ich weis echt nicht weiter!

Auch mit den QUtils Quellcodes (QBsp) kann ich nichts anfangen, weil Quake2 das ganze irgendwie in t_brush es abspeichert!?

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

zhlt sind afaik opensource...

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before

mh ich weiß nicht ob es eine referenz zu dem format gibt...
musst mal googlen falls du's ned schon gemacht hast...

sonst...

einfach mal simpel anfangen...
mach nen würfel in wc....
und guck dir dann den abschnitt für den würfel in der bsp an...
Quellcode:
{
( 64 192 192 ) ( 192 192 192 ) ( 192 64 192 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 -1 0 0 ] 0 1 1
( 64 64 64 ) ( 192 64 64 ) ( 192 192 64 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 -1 0 0 ] 0 1 1
( 64 192 192 ) ( 64 64 192 ) ( 64 64 64 ) ALIEN_ALPHA1 [ 0 1 0 0 ] [ 0 0 -1 0 ] 0 1 1
( 192 192 64 ) ( 192 64 64 ) ( 192 64 192 ) ALIEN_ALPHA1 [ 0 1 0 0 ] [ 0 0 -1 0 ] 0 1 1
( 192 192 192 ) ( 64 192 192 ) ( 64 192 64 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 0 -1 0 ] 0 1 1
( 192 64 64 ) ( 64 64 64 ) ( 64 64 192 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 0 -1 0 ] 0 1 1
}


dann überlegen wie es aufgebaut ist....
jede zeile entspricht einer fläche...

dann einfach nur eine betrachten erstmal:
Quellcode:
{
( 64 192 192 ) ( 192 192 192 ) ( 192 64 192 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 -1 0 0 ] 0 1 1


das erste sind irgendwie 3 punkte.... dann textur.... etc.

nur das mit nur 3 punkten wundert mich.... irgendwie wird in den sachen hinter der texturangabe drin sein wie sich der 4. punkt definiert im bezug auf die anderen...

errr... was schreib ich hier... mir fällt grad ein... es gab mal nen "mapping guide mit notepad" oso.... da war drin beschrieben wie man map's mit nem texteditor macht... vieleicht findest das mit googlen.. könnte sehr hilfreich sein weil da dann wahrscheinlich auch erklärt wird wie die sachen aufgebaut sind....

[EDIT]
hab mal aus langeweile gegooglet... da steht wie das aufgebaut ist... anhand der daten dürfte man sowas realtiv leicht umwandeln können...
http://www.geocities.com/adam_tebbutt_mckern/mapingwithnotepad.html
[/EDIT]

Nun ist deine Zeit gekommen sprach der Tod, stolperte und brach sich das Genick. :o

das is einfacher als man denk!

die drei Vektoren in einer Zeile:
Quellcode:
( 64 192 192 ) ( 192 192 192 ) ( 192 64 192 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 -1 0 0 ] 0 1 1


ergeben eine Ebene ( Mit dem Kreuzprodukt der Verbindgungsvektoren Normalenvektor aufstellen -> Vektorrechnung Oberstufe )

ein Würfel wird dann z.B. von 6 Ebenen umschlossen. So kann man beliebige (konvexe) dreidimansionale Objekte definieren.

bei WC werden für die Texturdefinition jeweils die u/v-Axen angegeben. also
Quellcode:
TEXTURNAME [ u1 u2 u3 shift_x ] [ v1 v2 v3 shift_y ] rotate scale_x scale_y


hoffe das hilft dir ein wenig.

noch was: für ne engine eignet sich dieses Format - sofern die Geometrie nich weiter bearbeitet wird - nicht wirklich für eine 3d-engine. Welche Art von Technolgie benutzt du denn? Octree, normal BSP oder was?

Ich benutz nen Octree und versuche gerade, irgendwie meinen Beamtree ans laufen zu bringen *g*. BSP muss ich mal gucken, ich hab k.A. wie man Rückwärts durch den Tree gehen soll...

Kennt jemand Artikel o.ä. zum Thema Beamtrees?? Auf gamedev.net sowie flipcode hab ich nichts gefunden...

Zu WC: Ich will ja erst mal nur Testmaps machen, Diablo_bth hat die Maps für seine Engine (90% Q2 Code??) auch mit WC gemacht.

Ich würd ja den UnrealED (Für UT Normal) benutzen, aber die Files sehen noch kryptischer aus!

/E:

Wenn bei:
( 64 192 192 ) ( 192 192 192 ) ( 192 64 192 ) ALIEN_ALPHA1 [ 1 0 0 0 ] [ 0 -1 0 0 ] 0 1 1

die [ u1 u2 u3 ...] [ v1 v2 v3 ...], wieso wird dann einmal u1 und dann nich v1 sondern v2 benutzt?? Das ist mir unklar. Sind die Standart-Koordinaten für eine Plane ( Muss man die Planes irgendwie miteinander beschneiden, um Polygone rauszubekommen? Wenn ja, verwerfe ich das lieber oder diabolo_bth postet den Quellcode von seinen BSP Utillities) irgendwie 0,0?

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

@Diabolo_bth: Dein HLBSPSlice ist echt klasse!
Sonst: Hast du das 100% selbst gecodet?

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

klar habe ich das 100% selbst gecodet -
das war der Vorgnänger zu meiner jetzigen Engine-Technologie.

Von Klassen für Vektoren, Matrizen, Ebenen, Polygonen, Nodes etc... habe ich alles komplett selbst entworfen - der ID-C-Style ist mir eben einfach zu unstrukturiert. (Obwohl ich John Carmack Arbeit sehr schätze!)
Dabei kann man auch alles einheitlich strukturieren, z.B. das IO-Management über streams etc.

auchja dass muss ich doch noch mal klarstellen:
AUCH MEINE ENGINE VERWENDET KEIN STÜCK Q2 CODE! alles ist komplett in c++ bzw. objektorientiert.

Mit dem q2-system ließe sich z.B. dynamische Berechnungen der BSP-Architektur nur sehr kompliziert bzw. garnicht realisieren, da die Geometrie in statischen Arrays abgespeichert wird.

Benutzt du nen dynamischen BSP Tree odda was? (Ich hab dynamische änderungen an der Levelarchitektur noch gar nicht gesehen :( )
Schreibst du noch nen eigenen Editor für die Engine?

(Sorry, das ich meine, das deine Engine wie q2 ist, aber die Konsolen-Tools machen die Ausgabe der q2 tools halt täuschend echt nach)

Wie lange codest du schon an der Engine?

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Ach ja: Kennt jemand gute tutorials zum Thema "Wie code ich einen 3D-Leveleditor für meine Engine" ?

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

was genau verändert wird habe ich hier gezeigt:
http://www.thewall.de/forum/showtopic.php?threadid=26184&post_start=75&time=1033850117

wenn du bei meinem engine-test den Wireframe-Modus einschaltest, so wirst du bemerken, dass um den Ventilator herum sich die Polygon-Architektur veändert. Ein editor habe ich auch angefange - bzw. den radiant modifiert, sodass er meine shader-scripts parsen kann.
Apropos: hat hier zufällig jemand bock einen editor zu schreiben/verändern oder gar Game-Logig für meine engine zu coden??

Game Logig?? => Loging (Log-Files) oder Logik?
Meinst du CPlayer::Walk(), CPlayer::Touched(CBaseItem* pItem), CBaseItem::Collide(CBaseThing* pThing) oder sowas?

Guck mal ins HLSDK das ist ein guter Ansatz sowas zu machen. Da du ColDet ja schon hast, ist das doch wohl ein Kinderspiel für dich *schleim*

Wo gibts den Radiant Source? auf ftp.idsoftware.com? Wenn ja zieh ich ihn mir mal und versuch was vom ID-C Style zu verstehen *g*

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

www.radiant.org oso

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before

Warst mal auf radiant.org?? Das hat damit AFAIK nichs zu tun.. Und der id FTP Server ist ma wieder strótzenlangsam

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

ftp://ftp.idsoftware.com/idstuff/ da musste dich halt durchwurschteln -> unter quake3, source oder radiant oder so.

Zitat:

aber die Konsolen-Tools machen die Ausgabe der q2 tools halt täuschend echt nach

ich glaube du hat noch nie mit q2 compiliert - da gibts nähmlich für die BSP, Sichtbarkeits- und Lichtberechnung ein eigenes Tool (im Gegensatz zu DBSP.exe) und die ganzen Ausgaben sind 1. auf English und geben 2. total andere Aussagen ab.

ich bin heute mal gnädig gestimmt und poste hier mal ein kleine wenig meines *.map-Parser-codes:

zunächst Teile der Vektor Klasse:
Quellcode:
class vector
{
public:
    union
    {
        double v[3];
        struct{ double x, y, z; };
    };
public:
    inline vector( double X=0, double Y=0, double Z=0 ){ x = X; y = Y; z = Z;    }
    inline vector( const double *v )                { x=v[0]; y=v[1]; z=v[2];    }
    inline vector( const float *v )                    { x=v[0]; y=v[1]; z=v[2];    }
    inline vector( const int *iv )                    { x=iv[0]; y=iv[1]; z=iv[2];}
    inline vector& operator=( const vector& v )        { x=v.x; y=v.y; z=v.z; return *this;    }    // wozu denn?

// Arithmetik
    inline vector operator+( const vector& v) const    { return vector(x+v.x, y+v.y, z+v.z);    }
    inline vector operator-( const vector& v) const    { return vector(x-v.x, y-v.y, z-v.z);    }
    inline vector operator*( const double fl) const { return vector(x*fl, y*fl, z*fl);        }
    inline vector operator/( const double fl) const { return vector(x/fl, y/fl, z/fl);        }

    inline vector Normalize( void ) const                                                // Einheitsvector
    {
        double ilen = 1.0 / sqrt( x*x + y*y + z*z  );
// rsqrt ist keine Standartfunktion!
    //    double ilen = rsqrt( x*x + y*y + z*z );
        return vector( x*ilen, y*ilen, z*ilen );
    }

    static inline vector CrossProduct( const vector& a, const vector& b)                    // Vektorielles/Kreuz Produkt
    { return vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }

    static inline double DotProduct( const vector& a, const vector& b)                        // SkalarProdukt
    { return(a.x*b.x + a.y*b.y + a.z*b.z); }

    static inline vector PlaneNormal( const vector& a, const vector& b, const vector& c )    // Flächen-Normale als Einheistvektor!
    { return vector::CrossProduct( a-b, c-b ).Normalize(); }



// eine Ebene
Quellcode:
class bsp_plane  
{
public:
    vector    normal;        // A, B, C components of the plane equation
    double    dist;        // D component of the plane equation
    int        axialtype;    // axialtype<3 axial
public:
    bsp_plane( const vector *v )
    {
        normal = vector::PlaneNormal( v[0], v[1], v[2] ); // Fächennormale
        dist = vector::DotProduct( v[1], normal );

        // snap_normal( normal ); // müsste ich erst erklären
        // dist = float_precision( dist ); // auch

        axialtype = 3;    // -1;
        if( normal.x == 1.0 || normal.x == -1.0 )
                axialtype = 0;
        if( normal.y == 1.0 || normal.y == -1.0 )
                axialtype = 1;
        if( normal.z == 1.0 || normal.z == -1.0 )
                axialtype = 2;
        }
// Funktionen...
};


// Parsing einer Ebenen *.map-Zeile
Quellcode:
void map_side::LoadMap_old( map_tree *tree )
{
    char    *shadername, *c;
    int        i, j, st_rotate;
    vector    points[3];    // für die *.map-Ebenedefinition
    vector    uv_vecs[2], st_vecs[2];
    vector2d    st_offset, st_scale;

    // die Flächendefinition lesen
    for( i=0 ; i<3 ; i++ )
    {
        ASSERT( strcmp( tree->mapscript->GetLastToken(), "(" ) );

        for( j=0 ; j<3 ; j++ )
            points[i ].v[j] = atof( tree->mapscript->GetToken() );

        ASSERT( strcmp( tree->mapscript->GetToken(), ")" ) );
        tree->mapscript->GetToken();
    }

    // Plane-Referenz schon hier!
    this->planeref = tree->planearray->push( bsp_plane( points ) );

    shadername = UTIL_CopyString( tree->mapscript->GetLastToken() );

    if( *shadername == '{' )    // wegen {TEXTURNAHME ! (lasse ich drin, man weiß ja nie!)
    {
        delete [] shadername;
        shadername = UTIL_CopyString( UTIL_VarArgs( "{%s", tree->mapscript->GetToken() ) );
    }

    if( tree->mapversion >= _WC_AXIAL_MAPVERSION ) // special wc-version?
    {
        for( i=0 ; i<2 ; i++ )
        {
            ASSERTS( strcmp( tree->mapscript->GetToken(), "[" ), "map_side::LoadMap_old: Fehlendes '[' in der Texturdefinition!" );

            uv_vecs[i ].x = atof( tree->mapscript->GetToken() );
            uv_vecs[i ].y = atof( tree->mapscript->GetToken() );
            uv_vecs[i ].z = atof( tree->mapscript->GetToken() );
            st_offset.v[i ]  = atof( tree->mapscript->GetToken() );

            ASSERTS( strcmp( tree->mapscript->GetToken(), "]" ), "map_side::LoadMap_old: Fehlendes '[' in der Texturdefinition!" );
        }

        st_rotate   = atoi( tree->mapscript->GetToken() );

        st_scale.v[0] = atof( tree->mapscript->GetToken() );
        st_scale.v[1] = atof( tree->mapscript->GetToken() );
    }
    else    // normales Quake-Format
    {
        st_offset.v[0] = atof( tree->mapscript->GetToken() );
        st_offset.v[1] = atof( tree->mapscript->GetToken() );

        st_rotate    = atoi( tree->mapscript->GetToken() );

        st_scale.v[0] = atof( tree->mapscript->GetToken() );
        st_scale.v[1] = atof( tree->mapscript->GetToken( true ) );    // damit mir das radiant-format keinen Strich durch
                                                                    // die Rechnung macht!!
        // calculate U/VAxis:
        int        sv, tv;
        double    sinv, cosv;
        double    ns, nt;

        TextureAxis( uv_vecs[0], uv_vecs[1], (*tree->planearray)[this->planeref] );

        // rotate axis
        if( st_rotate == 0.0 )
            { sinv = 0.0 ; cosv = 1.0; }
        else if( st_rotate == 90.0 )
            { sinv = 1.0 ; cosv = 0.0; }
        else if( st_rotate == 180.0 )
            { sinv = 0.0 ; cosv = -1.0; }
        else if( st_rotate == 270.0 )
            { sinv = -1.0 ; cosv = 0.0; }
        else
        {
            sinv = SIN( st_rotate );
            cosv = COS( st_rotate );
        }

        if( uv_vecs[0].x )
            sv = 0;
        else if( uv_vecs[0].y )
            sv = 1;
        else // if( uv_vecs[0].z )
            sv = 2;

        if( uv_vecs[1].x )
            tv = 0;
        else if( uv_vecs[1].y )
            tv = 1;
        else // if( uv_vecs[1].z )
            tv = 2;

        for( i=0 ; i<2 ; i++ )
        {
            ns = cosv * uv_vecs[i ].v[sv] - sinv * uv_vecs[i ].v[tv];
            nt = sinv * uv_vecs[i ].v[sv] + cosv * uv_vecs[i ].v[tv];
            uv_vecs[i ].v[sv] = ns;
            uv_vecs[i ].v[tv] = nt;
        }
    }

    if( st_scale.x == 0.0 ) st_scale.x = 1.0;
    if( st_scale.y == 0.0 ) st_scale.y = 1.0;

    // s/t Axen berechnen
    for( i=0 ; i<2 ; i++ )
        st_vecs[i ] = uv_vecs[i ] / st_scale.v[i ];

    // Texturname fixen
    c = shadername;
    while( *c = LOWERCASE( *c ) )
        c++;

    // Index-Referenzen
    this->shaderref = tree->shaderarray->push( bsp_shader( shadername ) );
    this->texinforef = tree->texinfoarray->push( bsp_texinfo( st_vecs, st_offset ) );
}


/edit
und das hier sieht nicht im Entfernesten nach quake-code aus

habs nachgeguckt, ist www.qeradiant.com

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before

Nee nach QCode nicht, das ist nicht objori.
Aber wie funktioniert das mit dem GetToken()? das hab ich bei den Qutils auch nicht kapiert. Sucht das immer die nächste Variable in der Datei oda was? Diese ID Leute machen mich immer verrückter! Wieso speichern die das ganze Zeugs nicht gleich als Vertices mit ordentlichen Texturkoordinaten ab?(Ich schätze mal, das hat was mit der Engine zu tun)

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

also dieses GetToken() is bei mir ne Funktion von der Klasse script_base, welche alle script-operationen erledigt. (bei Quake wird das natürlich global gemacht). GetToken() sucht im Prinzip einfach nach dem nächsten zusammenhängenden Text-Wort im '\0' terminierten Script-Buffer - überpsringt dabei '\n' Space und '\t' etc.. - und gibt einen char-Zeiger zurück

Das *.map-Format is halt ein Text und kein Binary Format - das wurde halt eben vor Jahren so entworfen. Ich habe da auch ein eigenes map-Format entworfen, welches einfach die Ebenen der Brushes in einem Hashtable speichert und die einzelne Brush-Seite hat dann nur noch Indices von einer Ebene, Shader und Texture-Alignment-Info. Das bringt das Format c.a. auf 25% der *.map Größe.
Auf das *.map-Format bin ich halt wegen WC und Radiant angewiesen - da ich nicht die Zeit habe einen eigenen Editor zu coden.

Hmm.. aber Q könnte das auch so speichern:

Quellcode:
[NUMBER_OF_WAD_FILES]
[WAD_FILE_PATH]
[NUMBER_OF_BRUSHES]
[BRUSHES
[NUMBER_OF_PLANES]
[PLANES]
]


Das wär doch viel einfacher zu verstehen!

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446