spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

            PDWORD pdwTemp = new DWORD[m_dwNumTriangles];
            DWORD dwCounter = 0;
            CBox BoundingBox(&m_pChilds[i]->m_vBoundingBoxMin, &m_pChilds[i]->m_vBoundingBoxMax);
            // Alle Dreiecke durchgehen und prüfen, ob sie im Bereich dieses
            // untergeordneten Knotens liegen
            D3DXVECTOR3 vTriA, vTriB, vTriC;
            for(DWORD j = 0; j < m_dwNumTriangles; j++)
            {
                // Vektoren dieses Dreiecks herausfinden
                vTriA = pVectors[pdwIndices[m_pdwTriangles[j] * 3]];
                vTriB = pVectors[pdwIndices[m_pdwTriangles[j] * 3 + 1]];
                vTriC = pVectors[pdwIndices[m_pdwTriangles[j] * 3 + 2]];
    
                // Wenn auch nur einer der Vektoren innerhalb der Bounding-Box
                // liegt, dann wird das Dreieck zu diesem untergeordneten Knoten gehören.
                // Gleiches gilt auch, wenn eine Seite des Dreiecks die Bounding-Box schneidet.
                if (BoundingBox.IntersectPoint(&vTriA) ||
                    BoundingBox.IntersectPoint(&vTriB) ||
                    BoundingBox.IntersectPoint(&vTriC) ||
                    BoundingBox.IntersectLine(&vTriA, &vTriB) ||
                    BoundingBox.IntersectLine(&vTriB, &vTriC) ||
                    BoundingBox.IntersectLine(&vTriC, &vTriA))
                {
                    // Dieses Dreieck zur temporären Liste hinzufügen
                    pdwTemp[dwCounter] = m_pdwTriangles[j];
                    dwCounter++;
                }
            }

            // Die Temporäre Liste zum untergeordneten Knoten kopieren
            m_pChilds[i]->SetTriangles(pdwTemp, dwCounter);

            // Temporäre Liste wieder freigeben
            SAFE_DELETE(pdwTemp);

Quellcode

BOOL COcTreeNode::SetTriangles(const LPDWORD pTriangles, DWORD dwCount)
{ 
    SAFE_DELETE_ARRAY(m_pdwTriangles);
    m_dwNumTriangles = dwCount; 
    if (m_dwNumTriangles > 0)
    {
        m_pdwTriangles = new DWORD[m_dwNumTriangles];
        assert(m_pdwTriangles != NULL);
        if (m_pdwTriangles != NULL)
        {
            if (pTriangles)
                CopyMemory(m_pdwTriangles, pTriangles, m_dwNumTriangles * sizeof(DWORD));
            else
            {
                for (DWORD ix = 0; ix < m_dwNumTriangles; ix++)
                    m_pdwTriangles[ix] = ix;
            }
            return TRUE;
        }
    }
    return FALSE;
}

Quellcode

HRESULT C3DModel::Update(LPDIRECT3DDEVICE9 pd3dDevice, BOOL bExtraData)
{
    // Boundingbox und Sphere bestimmen
    HRESULT hr = CalcBounds(pd3dDevice);
    if (FAILED(hr))
        return hr;

    assert(m_pMesh != NULL);
    if (FAILED(hr = m_pMesh->SetFVF(pd3dDevice, D3DVERTEX::FVF)))
        return hr;

    // Matrix aktualisieren
    UpdateMatrix();
    // wäre dumm, wenns nicht so wäre
    assert(m_pMesh->m_pSysMemMesh != NULL);
    m_dwNumFaces = m_pMesh->m_pSysMemMesh->GetNumFaces();
    m_dwNumVertices = m_pMesh->m_pSysMemMesh->GetNumVertices();
    assert(m_dwNumVertices > 0 && m_dwNumFaces > 0);
    // wenn angegeben, Dreiecke speichern (für Kollisionsabfrage im OcTree)
    if (bExtraData && m_dwNumVertices > 0 && m_dwNumFaces > 0)
    {
        m_pvVectors = new D3DXVECTOR3[m_dwNumVertices];
        assert(m_pvVectors != NULL);
        if (!m_pvVectors)
            return E_OUTOFMEMORY;

        // Speicher für die Ebenen der Dreiecke reservieren (3 Seiten und die Ebene des Dreiecks selbst)
        m_pTrianglePlanes = new D3DXPLANE[m_dwNumFaces * 4];
        if (!m_pTrianglePlanes)
        {
            SAFE_DELETE_ARRAY(m_pvVectors);
            return E_OUTOFMEMORY;
        }

        // Vectoren auslesen
        LPD3DXMESH pMesh = m_pMesh->GetSysMemMesh(); //m_pMesh->GetLocalMesh();
        assert(pMesh != NULL);

        PWORD pIndices = NULL;
        LPDIRECT3DINDEXBUFFER9 pIB = NULL;
        if (FAILED(hr = pMesh->GetIndexBuffer(&pIB)))
        {
            SAFE_DELETE_ARRAY(m_pvVectors);
            SAFE_DELETE_ARRAY(m_pTrianglePlanes);
            return hr;
        }
        if (FAILED(hr = pIB->Lock(0, 0, (void**)&pIndices, D3DLOCK_READONLY)))
        {
            SAFE_RELEASE(pIB);
            SAFE_DELETE_ARRAY(m_pvVectors);
            SAFE_DELETE_ARRAY(m_pTrianglePlanes);
            return hr;
        }
        D3DVERTEX* pVertices = NULL;
        if (FAILED(hr = pMesh->LockVertexBuffer(D3DLOCK_READONLY, (void**)&pVertices)))
        {
            pIB->Unlock();
            SAFE_DELETE_ARRAY(m_pvVectors);
            SAFE_DELETE_ARRAY(m_pTrianglePlanes);
            return hr;
        }
        // calculate vertex size
        DWORD dwVertexSize = D3DXGetFVFVertexSize(pMesh->GetFVF()), ix;
        // erst mal alle Vectoren auslesen
        for (ix = 0; ix < m_dwNumVertices; ix++)
            m_pvVectors[ix] = pVertices[ix].p;
        /*
        // Dreiecksvectoren in Abhängigkeit der Indices 
        D3DINDEXBUFFER_DESC Desc;
        // Die Beschreibung des Index-Buffers abfragen
        pIB->GetDesc(&Desc);
        PWORD pIndex;
        DWORD dwIndexSize = Desc.Format == D3DFMT_INDEX16 ? sizeof(WORD) : sizeof(DWORD);
        */
        D3DXVECTOR3 vTriA, vTriB, vTriC, vTriN, vTemp;
        D3DXPLANE pTemp;
        for (ix = 0; ix < m_dwNumFaces; ix++)
        {
            // Index herausfinden
            vTriA = m_pvVectors[pIndices[3 * ix]];
            vTriB = m_pvVectors[pIndices[3 * ix + 1]];
            vTriC = m_pvVectors[pIndices[3 * ix + 2]];
            
            // Ebene des Dreiecks berechnen
            D3DXPlaneFromPoints(&pTemp, &vTriA, &vTriB, &vTriC);
            D3DXVec3Cross(&vTriN, &D3DXVECTOR3(vTriC - vTriB), &D3DXVECTOR3(vTriA - vTriB));
            D3DXPlaneNormalize(&m_pTrianglePlanes[ix * 4], &pTemp);

            // Die drei Seitenebenen berechnen
            D3DXVec3Cross(&vTemp, &D3DXVECTOR3(vTriA - vTriB), &vTriN);
            D3DXVec3Normalize(&vTemp, &vTemp);
            D3DXPlaneFromPointNormal(&m_pTrianglePlanes[ix * 4 + 1], &vTriA, &vTemp);

            D3DXVec3Cross(&vTemp, &D3DXVECTOR3(vTriB - vTriC), &vTriN);
            D3DXVec3Normalize(&vTemp, &vTemp);
            D3DXPlaneFromPointNormal(&m_pTrianglePlanes[ix * 4 + 2], &vTriB, &vTemp);

            D3DXVec3Cross(&vTemp, &D3DXVECTOR3(vTriC - vTriA), &vTriN);
            D3DXVec3Normalize(&vTemp, &vTemp);
            D3DXPlaneFromPointNormal(&m_pTrianglePlanes[ix * 4 + 3], &vTriC, &vTemp);
        }
        pMesh->UnlockVertexBuffer();

        // Boundingbox-Knoten bilden
        m_pRootNode = new COcTreeNode;
        if (!m_pRootNode)
        {
            pIB->Unlock();
            pIB->Release();
            SAFE_DELETE_ARRAY(m_pvVectors);
            SAFE_DELETE_ARRAY(m_pTrianglePlanes);
            return E_OUTOFMEMORY;
        }
        m_pRootNode->SetBounds(m_BoundingBoxLocal.GetBoundsMin(), 
            m_BoundingBoxLocal.GetBoundsMax());
        // Dreiecke erst mal vollständig auf die Root setzen
        m_pRootNode->SetTriangles(NULL, m_dwNumFaces * 3);
        // Dreiecke aufteilen
        m_pRootNode->SplitNode(m_pvVectors, pIndices, 4);
        // Indexbuffer freigeben
        pIB->Unlock();
        pIB->Release();
    }
    return hr;
}