DGL • Thema anzeigen - c nach delphi uff

c nach delphi uff

Moderator: DGL-Team

Seite 1 von 1

[ 5 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

neq

Betreff des Beitrags: c nach delphi uff

Verfasst: Mo Apr 26, 2004 20:37

DGL Member

Registriert: Mi Mär 24, 2004 16:45
Beiträge: 29

Hi,

ich habe für mein spiel mir nen BSP (das mapformat) Loader geholt, der schon in delphi geschrieben ist. Er ist dem von gametutorials.com sehr ähnlich nur hat er leider nicht die super optimierung des in c geschriebenen Loaders von gametutorials.com.
Da sind noch irgentso dinger die sich leafs nennen (und noch so n kram) mit dem man glaub ich rausfindet in welchem teil des levels man ist und daher auch was gemalt werden muss. (das wird ja vom leveleditor vorberechnet und is deshalb extrem schnell)

also hab ich mir den code in c geholt und jetzt friemel ich mir die benötigten stücke raus und übersetzte sie nach delphi.
Bin leider nich grad so n experte in C und deshalb hab ich ziemlich schwierigkeiten damit ... aber hier ersma der teil den ich schon übersetzt hab.

Code:

 
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
 
    // In this function we read from a bunch of new lumps.  These include
    // the BSP nodes, the leafs, the leaf faces, BSP splitter planes and
    // visibility data (clusters).
 
    // Store the number of nodes and allocate the memory to hold them
    m_numOfNodes = lumps[kNodes].length / sizeof(tBSPNode);
    m_pNodes     = new tBSPNode [m_numOfNodes];
 
    // Seek to the position in the file that hold the nodes and store them in m_pNodes
    fseek(fp, lumps[kNodes].offset, SEEK_SET);
    fread(m_pNodes, m_numOfNodes, sizeof(tBSPNode), fp);
 
    // Store the number of leafs and allocate the memory to hold them
    m_numOfLeafs = lumps[kLeafs].length / sizeof(tBSPLeaf);
    m_pLeafs     = new tBSPLeaf [m_numOfLeafs];
 
    // Seek to the position in the file that holds the leafs and store them in m_pLeafs
    fseek(fp, lumps[kLeafs].offset, SEEK_SET);
    fread(m_pLeafs, m_numOfLeafs, sizeof(tBSPLeaf), fp);
 
    // Now we need to go through and convert all the leaf bounding boxes
    // to the normal OpenGL Y up axis.
    for(i = 0; i < m_numOfLeafs; i++)
    {
        // Swap the min y and z values, then negate the new Z
        int temp = m_pLeafs[i].min.y;
        m_pLeafs[i].min.y = m_pLeafs[i].min.z;
        m_pLeafs[i].min.z = -temp;
 
        // Swap the max y and z values, then negate the new Z
        temp = m_pLeafs[i].max.y;
        m_pLeafs[i].max.y = m_pLeafs[i].max.z;
        m_pLeafs[i].max.z = -temp;
    }
 
    // Store the number of leaf faces and allocate the memory for them
    m_numOfLeafFaces = lumps[kLeafFaces].length / sizeof(int);
    m_pLeafFaces     = new int [m_numOfLeafFaces];
 
    // Seek to the leaf faces lump, then read it's data
    fseek(fp, lumps[kLeafFaces].offset, SEEK_SET);
    fread(m_pLeafFaces, m_numOfLeafFaces, sizeof(int), fp);
 
    // Store the number of planes, then allocate memory to hold them
    m_numOfPlanes = lumps[kPlanes].length / sizeof(tBSPPlane);
    m_pPlanes     = new tBSPPlane [m_numOfPlanes];
 
    // Seek to the planes lump in the file, then read them into m_pPlanes
    fseek(fp, lumps[kPlanes].offset, SEEK_SET);
    fread(m_pPlanes, m_numOfPlanes, sizeof(tBSPPlane), fp);
 
    // Go through every plane and convert it's normal to the Y-axis being up
    for(i = 0; i < m_numOfPlanes; i++)
    {
        float temp = m_pPlanes[i].vNormal.y;
        m_pPlanes[i].vNormal.y = m_pPlanes[i].vNormal.z;
        m_pPlanes[i].vNormal.z = -temp;
    }
 
    // Seek to the position in the file that holds the visibility lump
    fseek(fp, lumps[kVisData].offset, SEEK_SET);
 
    // Check if there is any visibility information first
    if(lumps[kVisData].length) 
    {
        // Read in the number of vectors and each vector's size
        fread(&(m_clusters.numOfClusters),   1, sizeof(int), fp);
        fread(&(m_clusters.bytesPerCluster), 1, sizeof(int), fp);
 
        // Allocate the memory for the cluster bitsets
        int size = m_clusters.numOfClusters * m_clusters.bytesPerCluster;
        m_clusters.pBitsets = new byte [size];
 
        // Read in the all the visibility bitsets for each cluster
        fread(m_clusters.pBitsets, 1, sizeof(byte) * size, fp);
    }
    // Otherwise, we don't have any visibility data (prevents a crash)
    else
        m_clusters.pBitsets = NULL;
 
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
 
 

meine übersetzung:

Code:

 
/// new~~~~~~~~~~~~~~~~new
    // In this function we read from a bunch of new lumps.  These include
    // the BSP nodes, the leafs, the leaf faces, BSP splitter planes and
    // visibility data (clusters).
 
    // Store the number of nodes and allocate the memory to hold them
    m_numOfNodes := lumps[kNodes].length div sizeof(tBSPNode);
    SetLength(m_pNodes,m_numOfNodes);//     := new tBSPNode [m_numOfNodes];
 
    // Seek to the position in the file that hold the nodes and store them in m_pNodes
    seek(f, lumps[kNodes].offset);
    blockread(f,m_pNodes[0], m_numOfNodes*sizeof(tBSPNode));
    // Store the number of leafs and allocate the memory to hold them
    m_numOfLeafs := lumps[kLeafs].length div sizeof(tBSPLeaf);
    SetLength(m_pLeafs,m_numOfLeafs);//     = new tBSPLeaf [m_numOfLeafs];
 
    // Seek to the position in the file that holds the leafs and store them in m_pLeafs
    seek(f, lumps[kLeafs].offset);
    blockread(f,m_pLeafs[0], m_numOfLeafs*sizeof(tBSPLeaf));
 
    // Now we need to go through and convert all the leaf bounding boxes
    // to the normal OpenGL Y up axis.
    for i:=0 to m_numOfLeafs-1 do begin
        // Swap the min y and z values, then negate the new Z
        temp := m_pLeafs[i].min.y;
        m_pLeafs[i].min.y := m_pLeafs[i].min.z;
        m_pLeafs[i].min.z := -temp;
 
        // Swap the max y and z values, then negate the new Z
        temp := m_pLeafs[i].max.y;
        m_pLeafs[i].max.y := m_pLeafs[i].max.z;
        m_pLeafs[i].max.z := -temp;
  end;
 
    // Store the number of leaf faces and allocate the memory for them
    m_numOfLeafFaces := lumps[kLeafFaces].length div sizeof(integer);
    SetLength(m_pLeafFaces,m_numOfLeafFaces);//     = new int [m_numOfLeafFaces];
 
    // Seek to the leaf faces lump, then read it's data
    seek(f, lumps[kLeafFaces].offset);
    blockread(f,m_pLeafFaces[0], m_numOfLeafFaces*sizeof(integer));
 
    // Store the number of planes, then allocate memory to hold them
    m_numOfPlanes := lumps[kPlanes].length div sizeof(tBSPPlane);
    setLength(m_pPlanes,m_numOfPlanes);//     = new tBSPPlane [m_numOfPlanes];
 
    // Seek to the planes lump in the file, then read them into m_pPlanes
    seek(f, lumps[kPlanes].offset);
    blockread(f, m_pPlanes[0], m_numOfPlanes*sizeof(tBSPPlane));
 
    // Go through every plane and convert it's normal to the Y-axis being up
    for i:=0 to m_numOfPlanes-1 do begin
        temp := m_pPlanes[i].vNormal.y;
        m_pPlanes[i].vNormal.y := m_pPlanes[i].vNormal.z;
        m_pPlanes[i].vNormal.z := -temp;
  end;
 
    // Seek to the position in the file that holds the visibility lump
    seek(f, lumps[kVisData].offset);
 
    // Check if there is any visibility information first
    if (lumps[kVisData].length>0) then begin
 
        // Read in the number of vectors and each vector's size
    // also die beiden hier machn nen fehler
        blockread(f,m_clusters[0].numOfClusters,     1*sizeof(integer));
        blockread(f,m_clusters[0].bytesPerCluster, 1*sizeof(integer));
 
        // Allocate the memory for the cluster bitsets
// hier - das weiss ich noch nit weil ich noch nich den teil mit bitsets übersetzt hab
        int size = m_clusters.numOfClusters * m_clusters.bytesPerCluster;
        m_clusters.pBitsets = new byte [size];
 
        // Read in the all the visibility bitsets for each cluster
        blockread(f, m_clusters[0].pBitsets, 1*sizeof(byte) * size);
 
    // Otherwise, we don't have any visibility data (prevents a crash)
    end ;//else
        //m_clusters.pBitsets = NULL;
/// new~~~~~~~~~~~~~~~~end
 

also wer jetzt immer noch bock hat weiterzulesen...
Also ich bin mir ersma total unsicher ob das was ich übersetzt hab überhaupt richtig ist - hab nich ma n c compiler und da der code noch nich fertig übersetzt ist weiss ich auch nich ob ich das richtig übersetzt hab.
Also falls jemand beim drübergucken nen Fehler findet bitte sagt es mir ...

aber jetzt zu meinm wirklichn problem:

Code:

 
        // Read in the number of vectors and each vector's size
    // also die beiden hier machn nen fehler
        blockread(f,m_clusters[0].numOfClusters,     1*sizeof(integer));
        blockread(f,m_clusters[0].bytesPerCluster, 1*sizeof(integer));
 

Dieser Code läuft nicht und ich weiss nicht wie er korrekt lauten müsste.

Falls jemand tatsächlich so nen langen post freiwillig durchgelesen hat und mir dann auch noch helfen kann - schon ma thx im vorraus

ps: falls jemand weiss wo es schon ne fertige übersetzung vom gametutorials code gibt wäre ich sehr dankbar

Nach oben

rswm

Betreff des Beitrags:

Verfasst: Di Apr 27, 2004 17:15

DGL Member

Registriert: Mi Aug 28, 2002 19:27
Beiträge: 568
Wohnort: Chemnitz / Sachsen

erstens : die leafs sollten eigentlich in jeden sinnvollen bsp-loader sein.
zweitens : die vorgerechneten dinger sind wahrscheinlich PVS - Daten.

ich würde man auf zfx.com (oder org, net, de, oder so) schaun, da hat jemand einen bsp-loader in delphi für dx, das sollte nicht sooo schwierig sein.

bei den blockread muss ich mal fragen, was da fürn fehler kommt, es kann am datentyp liegen, oder an den dateien an sich.

_________________
Aktuelles Projekt :
www.PicPlace.de

Nach oben

LarsMiddendorf

Betreff des Beitrags:

Verfasst: Di Apr 27, 2004 17:51

DGL Member

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244

Hier http://harry.paintner.bei.t-online.de/Q3MapView/ gibt es auch einen recht fortgeschrittenen Q3Bsp Viewer mit Delphi Quelltext.
Was mich in deinem Quelltext wundert ist die Anpassung der Achsen. Bei Quake ist die Z Achse nach oben, aber das kann man doch eigentlich so lassen.

Nach oben

red

Betreff des Beitrags:

Verfasst: Di Apr 27, 2004 18:35

DGL Member

Registriert: Mo Feb 24, 2003 18:19
Beiträge: 165
Wohnort: Cologne

zum blockread:

ich denke du hast beim Aufruf der Prozedur Reset auch den zweiten Parameter mit drin, denn sonst würde das andere auch nicht laufen

-> reset(f, 1);

Du könntest schonmal einige Sachen ausschließen wenn du ausserdem bei den fehlerhaften BlockRead's einen vierten Parameter mitangibst, sprich eine variable in die die tatsächliche Byte-Menge geschrieben wird. wenn der fehler dann immer noch auftritt liegt es schonmal nicht dadran, dass dein programm aus irgendwelchen gründen am datei-ende lesen will... ansonsten mal gucken ob auch mit dem array alles stimmt - ich weiss zwar net ob der dynamisch ist aber jedenfalls ist kein SetLength(m_Clusters, .... in deinem Code-Snippet

_________________
www.omfg.biz - aktuelles projekt

Nach oben

neq

Betreff des Beitrags:

Verfasst: Do Apr 29, 2004 15:56

DGL Member

Registriert: Mi Mär 24, 2004 16:45
Beiträge: 29

ja das mit dem dynamischen array könnte sein...

dann danke erstmal und ich werde dass sobald ich zeit hab alles ausprobieren.

melde mich dann wieder um zu sagen obs geklappt hat.

Nach oben

Seite 1 von 1

[ 5 Beiträge ]

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 9 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.