spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// Kollision zwischen Box und Octree berechnen (rekursiv)
TRIBASE_API BOOL tbBoxHitsOctreeRec(const tbVector3& vBoxA,
                                     const tbVector3& vBoxB,
                                     tbMatrix mTransformation,
                                     const tbOctree* pOctree,
                                     const tbOctreeNode* pNode,
                                     int* piClosestTriangle,
                                     float* pfClosestCollision,
                                     tbOctreeNode** ppClosestNode,
                                     BOOL bSimpleMode,
                                     BOOL* pbStop)
{
    // Prüfen, ob der Quader den Umgebungsquader des Knotens trifft.
    // Falls nicht, können wir sofort abbrechen
    if(!tbBoxHitsBox(vBoxA, vBoxB, mTransformation,
                      pNode->vBoundingBoxMin,
                      pNode->vBoundingBoxMax,
                      tbMatrixIdentity(), 3))
    {
        // Abbruch!
        return FALSE;
    }

    // Ist dieser Knoten ein Endknoten? Falls ja, dann testen wir die
    // Kollision jetzt auf Dreiecksebene.
    if(pNode->bIsLeaf)
    {
        // Nun jedes Dreieck dieses Knotens durchgehen und
        // nach der nächsten Kollisionen suchen
        for(DWORD t = 0; t < pNode->dwNumIndices / 3; t++)
        {                       
            /*1. Testen, ob die drei Verbindungslinien im Dreieck die Box treffen 
            2. Testen, ob die Seitenhalbierenden die Box treffen 

            Wenn beides zutrifft, schneidet das Dreieck die Box. */

            if(COLLISION)
            {
                // Wenn der Benutzer den Ort der Kollision nicht kennen möchte
                // (bSimpleMode = TRUE), dann können wir jetzt schon abbrechen.
                if(bSimpleMode)
                {
                    *pbStop = TRUE;
                    return TRUE;
                }
            }
        }
    }
    else
    {
        // Dieser Knoten ist kein Endknoten.
        // Wir gehen seine Unterknoten durch und testen diese.
        for(DWORD i = 0; i < 8; i++)
        {
            tbBoxHitsOctreeRec(vBoxA, vBoxB, mTransformation, pOctree, pNode->apChild[i],
                                piClosestTriangle, pfClosestCollision, ppClosestNode,
                                bSimpleMode, pbStop);

            // Wurde die pbStop-Variable auf TRUE gesetzt?
            // Falls ja, dann brechen wir ab und liefern TRUE zurück.
            if(*pbStop) return TRUE;
        }

        // Wenn es eine Kollision gab, wird TRUE geliefert.
        if(*piClosestTriangle != -1) return TRUE;
    }

    // Keine Kollision!
    return FALSE;
}

// ******************************************************************
// Kollision zwischen Linie und Octree berechnen
TRIBASE_API BOOL tbBoxHitsOctree(const tbVector3& vBoxA,
                                  const tbVector3& vBoxB,
                                  tbMatrix mTransformation,
                                  const tbOctree* pOctree,
                                  const float fTolerance,   // = 0.0f
                                  tbVector3* pvOutPos,      // = NULL
                                  tbVector3* pvOutNormal,   // = NULL
                                  int* piOutTriangle,       // = NULL
                                  tbOctreeNode** ppOutNode) // = NULL
{
    // Parameter prüfen
    if(pOctree == NULL)         TB_ERROR_NULL_POINTER("pOctree", TB_ERROR);
    if(!pOctree->m_bExtraData)  TB_ERROR("Der Octree hat keine Extradaten!", TB_ERROR);


    // Startwerte setzen
    int iClosestTriangle = -1;
    float fClosestCollision = 100000.0f;
    BOOL bStop = FALSE;
    tbOctreeNode* pNode;

    // Rekursive Funktion aufrufen
    tbBoxHitsOctreeRec(vBoxA, vBoxB, mTransformation, pOctree, pOctree->m_pRootNode,
                        &iClosestTriangle, &fClosestCollision, &pNode,
                        pvOutPos == NULL, &bStop);

    // Gab es eine Kollision?
    if(iClosestTriangle != -1)
    {
        // Falls erwünscht: Ort der Kollision berechnen
        //if(pvOutPos != NULL) *pvOutPos = vLineA + fClosestCollision * (vLineB - vLineA);

        // Normalvektor des getroffenen Dreiecks eintragen
        if(pvOutNormal != NULL)
        {
            // Wir erhalten den Normalvektor aus der Ebenengleichung des getroffenen Dreiecks.
            *pvOutNormal = pNode->pTrianglePlanes[iClosestTriangle * 4].n;
        }

        // Das getroffene Dreieck und den Knoten selbst eintragen
        if(piOutTriangle != NULL) *piOutTriangle = iClosestTriangle;
        if(ppOutNode != NULL) *ppOutNode = pNode;

        return TRUE;
    }

    // Keine Kollision!
    return FALSE;
}

Quellcode

        // Alle Dreiecke vom Octree durchgehen
        for(DWORD tb = 0; tb < pOctreeNode->dwNumIndices / 3; tb++)
        {
        }

Quellcode

        // Ersten Vektor dieses Dreiecks vom Octree transformieren
            pvVector = &pOctree->m_pvVectors[pOctreeNode->pdwIndices[tb * 3]];
            vTriA.x = pvVector->x * mInvMatrix.m11 + pvVector->y * mInvMatrix.m21 + pvVector->z * mInvMatrix.m31 + mInvMatrix.m41;
            vTriA.y = pvVector->x * mInvMatrix.m12 + pvVector->y * mInvMatrix.m22 + pvVector->z * mInvMatrix.m32 + mInvMatrix.m42;
            vTriA.z = pvVector->x * mInvMatrix.m13 + pvVector->y * mInvMatrix.m23 + pvVector->z * mInvMatrix.m33 + mInvMatrix.m43;

            // Zweiten Vektor dieses Dreiecks vom Octree transformieren
            pvVector = &pOctree->m_pvVectors[pOctreeNode->pdwIndices[tb * 3 + 1]];
            vTriB.x = pvVector->x * mInvMatrix.m11 + pvVector->y * mInvMatrix.m21 + pvVector->z * mInvMatrix.m31 + mInvMatrix.m41;
            vTriB.y = pvVector->x * mInvMatrix.m12 + pvVector->y * mInvMatrix.m22 + pvVector->z * mInvMatrix.m32 + mInvMatrix.m42;
            vTriB.z = pvVector->x * mInvMatrix.m13 + pvVector->y * mInvMatrix.m23 + pvVector->z * mInvMatrix.m33 + mInvMatrix.m43;

            // Dritten Vektor dieses Dreiecks vom Octree transformieren
            pvVector = &pOctree->m_pvVectors[pOctreeNode->pdwIndices[tb * 3 + 2]];
            vTriC.x = pvVector->x * mInvMatrix.m11 + pvVector->y * mInvMatrix.m21 + pvVector->z * mInvMatrix.m31 + mInvMatrix.m41;
            vTriC.y = pvVector->x * mInvMatrix.m12 + pvVector->y * mInvMatrix.m22 + pvVector->z * mInvMatrix.m32 + mInvMatrix.m42;
            vTriC.z = pvVector->x * mInvMatrix.m13 + pvVector->y * mInvMatrix.m23 + pvVector->z * mInvMatrix.m33 + mInvMatrix.m43;

Quellcode

vTriA=&pOctree->m_pvVectors[pOctreeNode->pdwIndices[tb * 3]];;
vTriB=&pOctree->m_pvVectors[pOctreeNode->pdwIndices[(tb * 3) + 1]];
vTriC=&pOctree->m_pvVectors[pOctreeNode->pdwIndices[(tb * 3) + 2]];