BSP und Editor

Übersicht BlitzBasic Blitz3D

Neue Antwort erstellen

 

mark99

Betreff: BSP und Editor

BeitragFr, Aug 27, 2004 10:54
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragFr, Aug 27, 2004 10:57
Antworten mit Zitat
Benutzer-Profile anzeigen
eventuell Droplet, bin mir aber nicht sicher, ob der Bsps laden kann.
between angels and insects
 

DoomMaster

BeitragFr, Aug 27, 2004 12:23
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragFr, Aug 27, 2004 12:32
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragFr, Aug 27, 2004 13:13
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 3:20
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 9:17
Antworten mit Zitat
Benutzer-Profile anzeigen
@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

BeitragSa, Aug 28, 2004 9:28
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 11:47
Antworten mit Zitat
Benutzer-Profile anzeigen
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. Smile

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. Smile

grüße
http://bl4ckd0g.funpic.de

Jolinah

BeitragSa, Aug 28, 2004 19:45
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 20:03
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 20:37
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 20:58
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSa, Aug 28, 2004 21:04
Antworten mit Zitat
Benutzer-Profile anzeigen
Danke! Smile

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 Very Happy (bzw. wusste ich gar nicht das der Aufbau der BSP auch in der SDK zu finden ist. Ich dachte das es in HL selbst integriert ist.)

Jolinah

BeitragSa, Aug 28, 2004 23:02
Antworten mit Zitat
Benutzer-Profile anzeigen
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 Very Happy
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... Smile
 

David

BeitragSa, Aug 28, 2004 23:31
Antworten mit Zitat
Benutzer-Profile anzeigen
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:

Arrow 1 = Polygon
Arrow 2 = Patch
Arrow 3 = Mesh
Arrow 4 = Flare

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

Arrow nVertex
Arrow nNumVertexes

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? Smile
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

BeitragSa, Aug 28, 2004 23:49
Antworten mit Zitat
Benutzer-Profile anzeigen
Danke nochmal Very Happy


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

BeitragSo, Aug 29, 2004 13:45
Antworten mit Zitat
Benutzer-Profile anzeigen
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

BeitragSo, Aug 29, 2004 15:13
Antworten mit Zitat
Benutzer-Profile anzeigen
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. Smile

grüße
http://bl4ckd0g.funpic.de

Neue Antwort erstellen


Übersicht BlitzBasic Blitz3D

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group