BSP und Editor
Übersicht

mark99Betreff: BSP und Editor |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Guten morgen,
hab hier nix dergleichen gefunden auch im Englishen Forum nicht. Gibt es einen Editor mit dem ich bsp laden und dann *.b3d Pflanzen und Bäume in dieser bsp map setzen kann? Jede Pflanze und jeden Baum per Hand zu setzen ist doch etwas mühsam. Oder gibs derweil schon ganz andere Lösungen dazu? Danke Mark |
||
![]() |
Jan_Ehemaliger Admin |
![]() Antworten mit Zitat ![]() |
---|---|---|
eventuell Droplet, bin mir aber nicht sicher, ob der Bsps laden kann. | ||
between angels and insects |
DoomMaster |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
oder nen eigenen editor schreiben und dann die positionen der Gegenstände in einer einfachen txt datei speichern | ||
Für ewentuelle Rechtschreibfehler ist mein Duden verantwortlich |
mark99 |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Hi,
da ich noch nicht so fest in b3d drin bin, wäre das wphl ein Problem für mich. Werde mal dran üben ob ich sowas nicht auch hinbekomme. Danke:) |
||
![]() |
Vertex |
![]() Antworten mit Zitat ![]() |
---|---|---|
https://www.blitzforum.de/viewtopic.php?t=1133
ich glaube, man kann selber Entitys mit z.B. Q3Radiant definieren. Es kommt ja nur auf die Position, Rotation und eventuell die Größe an. mfg olli |
||
vertex.dreamfall.at | GitHub |
![]() |
Jolinah |
![]() Antworten mit Zitat ![]() |
---|---|---|
Weiss jemand zufällig wie die Half Life 1 BSP's aufgebaut sind?
Dann könnt ich für die ne eigene Laderoutine schreiben. Die Quake Editoren mag ich nicht so, ich benutz meistens World Craft. Aber ich habs noch nicht hinbekommen eine HL Bsp in Blitz zu laden mit der eingebauten Funktion. Ist wohl anders aufgebaut. |
||
2paul |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
@Jolinah
es gibt verschiedene bsp´s , quake1, quake2, quake3, HL und noch nen paar, soweit ich weiss kann blitz nur quake3... was aber geht, die texturen aus den wad´s mit wally extrahieren das das ganze in unwarp oder bsp-factory öffnen und dann eben als b3d exportierern, dabei verlierste aber die lightmaps... oki |
||
![]() |
Vertex |
![]() Antworten mit Zitat ![]() |
---|---|---|
Also ich habe damals meine Maps immer in Hammer erstellt, durch ein Konvertor gejagt und schon konnte ich sie auch in Blitz laden. Die HL und BSP Maps unterscheiden sich soweit ich weiss nur in den Texturkoordinaten. | ||
vertex.dreamfall.at | GitHub |
David |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Hi!
Angeblich sind die einzigen Unterschiede die benutzung von 24 Bit Lightmaps bei Halflife und die Anordnung der Lumps. Obs stimmt müsst man mal überprüfen. ![]() Edit: Das mit der Lumpanordnung stimmt schonmal: Hier(Quake2) und im HalfLife SDK Sourcecode steht: Code: [AUSKLAPPEN] #define LUMP_ENTITIES 0 #define LUMP_PLANES 1 #define LUMP_TEXTURES 2 #define LUMP_VERTEXES 3 #define LUMP_VISIBILITY 4 #define LUMP_NODES 5 #define LUMP_TEXINFO 6 #define LUMP_FACES 7 #define LUMP_LIGHTING 8 #define LUMP_CLIPNODES 9 #define LUMP_LEAFS 10 #define LUMP_MARKSURFACES 11 #define LUMP_EDGES 12 #define LUMP_SURFEDGES 13 #define LUMP_MODELS 14 #define HEADER_LUMPS 15 Was natürlich beim laden zu Fehlern führen muss Auserdem ist die HalfLife Bsp Version 30 und für Quake2 38. Für alle weiteren Unterschiede müsste man wohl die Sourcecodes zu den HalfLife - und Quake2 Bsp Compilern durchforsten. ![]() grüße |
||
http://bl4ckd0g.funpic.de |
![]() |
Jolinah |
![]() Antworten mit Zitat ![]() |
---|---|---|
Danke,
wozu sind diese Lumps eigentlich (was immer das auch sein soll)? Eine art Identifikation was gespeichert ist? Ich meine wenn LUMP_TEXTURES (=2) in der Bsp File an einer bestimmten Stelle steht so sind die nachfolgenden Daten Texturen? Naja ich sollte mich wohl mal über den genauen Aufbau der BSP's informieren (CSG usw.) |
||
David |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Hi!
Ich versuchs mal ein wenig zu erklähren: Code: [AUSKLAPPEN] typedef struct tagQ3Lump { int m_uOffset; int m_uLength; } Q3Lump_t; typedef struct tagQ3Header { int m_uMagic; int m_uVersion; Q3Lump_t m_lumps[ Q3NUMLUMPS ]; } Q3Header_t; Also, jede BSP Datei fängt mit der Header-Struktur an (4 bytes magic number, 4 bytes Versionnummer) Dann kommt eine Liste von sog. Lumps. Jeder Lump hat ein Offset und eine Länge, das Offset ist die Position der Daten vom Beginn der Datei aus gesehen und die Länge eben die Länge der Daten. Wenn man nun also die Faces aus der Datei laden will muss man im Lump 13 den Offset raussuchen an die Stelle der Datei springen und kann dann die soviel Bytes laden, wie in der Länge des Lumps vermerkt ist. Easy nicht? Das ist z.B. die Durchnummerierung der Lumps für Quake3 Bsp Maps: Code: [AUSKLAPPEN] enum Lumps { lump_Entities, lump_Shaders, lump_Planes, lump_Nodes, lump_Leafs, lump_Leaffaces, lump_Leafbrushes, lump_Models, lump_Brushes, lump_Brushsides, lump_Vertexes, lump_Meshverts, lump_Effects, lump_Faces, lump_Lightmaps, lump_Lightvols, lump_Visdata }; CSG Informationen stehen übrigens in keiner kompilierten IBSP Datei mehr. grüße |
||
http://bl4ckd0g.funpic.de |
![]() |
Jolinah |
![]() Antworten mit Zitat ![]() |
---|---|---|
Aso, danke für die tolle Erklärung. Ist ja wirklich ganz leicht.
Jetzt weiss ich auch was damit gemeint ist das in HL die Lumps verdreht sind. Dann wird bei HL Bsp maps natürlich an der falschen Stelle gelesen und es gibt Fehler... Mal schauen vielleicht krieg ich jetzt ja ne eigene Lade Routine hin. Sobald ich weiss wie die Faces usw. gespeichert werden (ich mein innerhalb dieses Lumps). |
||
David |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Hi!
Vielleicht hift dir das ja was: Code: [AUSKLAPPEN] #if !defined( Q3_TYPES_H ) #define Q3_TYPES_H #include "Types.h" #include "Vector3.h" #include "Vector2.h" #define Q3IDENT ( ( 'P' << 24 ) | ( 'S' << 16 ) | ( 'B' << 8 ) | 'I' ) #define Q3VERSION 0x2e #define Q3NUMLUMPS 17 #define Q3MAX_PATH 64 typedef struct tagQ3Lump { int m_uOffset; int m_uLength; } Q3Lump_t; typedef struct tagQ3Header { int m_uMagic; int m_uVersion; Q3Lump_t m_lumps[ Q3NUMLUMPS ]; } Q3Header_t; typedef struct tagQ3Shader { char m_cName[ 64 ]; int m_uFlags; int m_uContents; } Q3Shader_t; typedef struct tagQ3Plane { CVector3 m_vNormal; float m_fDist; } Q3Plane_t; typedef struct tagQ3Node { int m_uPlane; int m_nChildren[ 2 ]; CVector3 m_vMins; CVector3 m_vMaxs; } Q3Node_t; typedef struct tagQ3Leaf { int m_nCluster; int m_nArea; CVector3 m_vMins; CVector3 m_vMax; int m_nLeafface; int m_nNumLeaffaces; int m_nLeafbrush; int m_nNumLeafbrushes; } Q3Leaf_t; typedef struct tagQ3Leafface { int m_uFace; } Q3Leafface_t; typedef struct tagQ3Leafbrush { int m_uBrush; } Q3Leafbrush_t; typedef struct tagQ3Model { CVector3 m_vMins; CVector3 m_vMaxs; int m_uFace; int m_uNumFaces; int m_uBrush; int m_uNumBrushes; } Q3Model_t; typedef struct tagQ3Brush { int m_uBrushside; int m_uNumBrushsides; int m_uTexture; } Q3Brush_t; typedef struct tagQ3Brushside { int m_uPlane; int m_uTexture; } Q3Brushside_t; typedef struct tagQ3Vertex { CVector3 m_vPosition; CVector2 m_vTexcoord; CVector2 m_vLMCoords; CVector3 m_vNormal; ubyte m_uColor[ 4 ]; } Q3Vertex_t; typedef struct tagQ3Meshvert { int m_uOffset; } Q3Meshvert_t; typedef struct tagQ3Effect { char m_cName[ 64 ]; int m_uBrush; int m_uUnknown; } Q3Effect_t; typedef struct tagQ3Face { int m_uTexture; int m_uEffect; int m_uType; int m_uVertex; int m_uNumVertexes; int m_uMeshverts; int m_uNumMeshverts; int m_uLMIndex; int m_vLMStart[ 2 ]; int m_vLMSize[ 2 ]; CVector3 m_vLMOrigin; CVector3 m_vLMVecs[ 2 ]; CVector3 m_vNormal; int m_vSize[ 2 ]; } Q3Face_t; typedef struct tagQ3Lightmap { byte m_uMap[ 49152 ]; } Q3Lightmap_t; typedef struct tagQ3Lightvol { ubyte m_uAmbient[ 3 ]; ubyte m_uDirectional[ 3 ]; ubyte m_uDir[ 2 ]; } Q3Lightvol_t; typedef struct tagQ3Visdata { int m_uNumVecs; int m_uSzVecs; } Q3Visdata_t; enum Lumps { lump_Entities, lump_Shaders, lump_Planes, lump_Nodes, lump_Leafs, lump_Leaffaces, lump_Leafbrushes, lump_Models, lump_Brushes, lump_Brushsides, lump_Vertexes, lump_Meshverts, lump_Effects, lump_Faces, lump_Lightmaps, lump_Lightvols, lump_Visdata }; #endif Mein Projekt unterstüzt zwar nur Quake3 Maps aber es dürft sich ja nicht grundlegend von HalfLife Maps unterscheiden. (HalfLife basierte ja auf der Quake2 Engine). Falls doch kannst du ja mal nach dem SDK Sourcecode von HalfLife suchen. grüße |
||
http://bl4ckd0g.funpic.de |
![]() |
Jolinah |
![]() Antworten mit Zitat ![]() |
---|---|---|
Danke! ![]() Habs zwar grad selber gefunden. Hl SDK hab ich bereits, hab schon diverse kleinere Mod's gemacht. Jedoch nie veröffentlicht. War aber wohl zu dumm das BSP zeugs zu finden ![]() |
||
![]() |
Jolinah |
![]() Antworten mit Zitat ![]() |
---|---|---|
Ich hab bisschen rumprobiert. Konnte die Daten ohne Probleme auslesen.
Allerdings weiss ich nicht so ganz wie ich das ganze Umsetzen soll. Ich verstehe das System noch nicht ganz. So wie ich das sehe steht in der Face Struct ein Int welcher die ID des ersten Edges angibt. Im Edge ist dann ein Array wo irgendwie die Vertice IDs gespeichert sind und im Vertex ist dann wieder ein Float Array wo die Koordinaten des Vertex drin stehen. Aber dann gibts noch Planes, SurfaceEdges und anderes Zeugs.. Deswegen versteh ich das nicht ganz ![]() Ich weiss nicht was ich denn nun alles genau brauche um nur die Welt ohne Lightmaps (vorerst) darzustellen. Wahrscheinlich ist es schon einfacher nur ein Konverter zu schreiben und dann die Map mit der normalen Blitz funktion zu laden. Und wie ich gehört habe gibts ja schon Konverter... ![]() |
||
David |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Hi!
Das ganze ist eigendlich ganz simpel, wenn du erstmal nur die Geometrie ohne Lightmaps, Shader, Bezier Patches usw darstellen willst. Es gibt vier Facetypen im IBSP Format: ![]() ![]() ![]() ![]() Für die grobe Geometrie interessieren zuerst einmal nur die "normalen" Polygone. Patches sind die allseitsbekannten gegrümten Oberflächen und müssen per Software erst berechnet werden. Meshes sind statische "Levelmodels" wie Statuen usw... Also, um deine ganze Faceliste zu zeichnen musst du dein Facearray durchlaufen, den Typ prüfen und sollte dieser 1 sein kannst du das Face rendern. Nun hat jedes Face noch zwei weitere Informationen ![]() ![]() nVertex sagt dir den Index des ersten Vertex für dein Face in deinem Vertexarray und nNumVertex ist die Anzahl der Vertices von nVertex aus gesehen. Klar? Total Easy das ganze oder? Bei Meshes und Flares geht das ganze ein wenig anders und Patches musst du, wie gesagt selbst berechnen. Lustig wird es aber erst, wenn du Shader einbaust. Dann musst du die Faces nämlich erst noch sortieren und in der richtige Reinehfolge rendern. Wie sähe es denn aus, wenn du ein Fenster zu beginn renderst und erst danach Objekte die eigendlich dahinterliegen? ![]() Naja, soviel dazu. Achja, um das Rendern ein wenig zu optimieren kannst du noch Frustumculling und PVS einbauen. Die dazu benötigten Daten werden praktischerweise, in der Map, gleich mitgeliefert. grüße |
||
http://bl4ckd0g.funpic.de |
![]() |
Jolinah |
![]() Antworten mit Zitat ![]() |
---|---|---|
Danke nochmal ![]() Bei Quake 3 ist es so wie du das beschrieben hast. Aber in dem BSP_tool von botman für HL sind die Strukturen ziemlich anders. Code: [AUSKLAPPEN] // Face typedef struct { short planenum; short side; int firstedge; // we must support > 64k edges short numedges; short texinfo; // lighting info byte styles[MAXLIGHTMAPS]; int lightofs; // start of [numstyles*surfsize] samples } dface_t; //Edge typedef struct { unsigned short v[2]; // vertex numbers } dedge_t; //Vertex typedef struct { float point[3]; } dvertex_t; Deshalb war ich bisschen verwirrt *g* Da weiss ich jetzt nicht ob mit First Edge ein Index für dedge_t oder für dvertex_t gemeint ist. Ich denke schon eher dedge_t. Aber was mir nicht klar ist wieso in dedge_t 2 Vertex nummern drin sind? Naja ist ja nicht so wichtig. Das Projekt hat für mich niedrige Priorität. Dachte nur das ich das ja mal versuchen könnte jetzt wo ich grad kein anderes Projekt am laufen hab. |
||
mark99 |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Da sich doch einige gut mit dem Thema bsp auskennen:)
Ich hab ja nu schon rausgefunden wie ich eigene Modelle im Editor verwende, nur möchte icha uch Bäume und Pflanzen ssetzen, allerdings , wie sprech ich das die Alphawerte an? so das die Bäume nicht diese Schwarzen platten haben sonder das geäst normal aussieht? Hoffe ihr wisst wa sich meine, kann ich das im Shader definieren so das der bsp Compiler das auch gleich richtig umsetzt? Mark |
||
David |
![]() Antworten mit Zitat ![]() |
|
---|---|---|
Hi!
Nein, denn Shader werden nicht von den Routinen, die Blitzbasic bereitstellt, unterstüzt! Evtl. funktioniert das mit dem Alphablending, aber ich bezweifle das eher, denn das ganze geblende wird beim IBSP Format über Shader geregelt. ![]() grüße |
||
http://bl4ckd0g.funpic.de |
Übersicht


Powered by phpBB © 2001 - 2006, phpBB Group