spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

    //Terrain Zeichnen
    D3D.SetRS(D3DRS_CULLMODE, D3DCULL_NONE);
    D3D.SetRS(D3DRS_LIGHTING, FALSE);

    D3D->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    D3D->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    D3D->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
    D3D.SetTexture(0, g_pTerrainTexture);

    D3D->SetStreamSource(0, g_TerrainVertex->GetVB(), 0, sizeof(TerrainVertex));
    D3D->SetFVF(CUSTOMFVF);
    D3D->SetIndices(g_TerrainIndex->GetIB());
    D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,WIDTH*HEIGHT,0,(WIDTH-1)*(HEIGHT-1)*2);

    //Ende Terrain, Licht wieder an

    D3D.SetRS(D3DRS_LIGHTING, TRUE);

    // Motion-Blurring
    if(D3D.GetCaps().SrcBlendCaps & D3DPBLENDCAPS_BLENDFACTOR)
    {
        // Alpha-Blending aktivieren und verhindern, dass in den Z-Buffer geschrieben wird
        D3D.SetRS(D3DRS_ZWRITEENABLE, FALSE);
        D3D.SetRS(D3DRS_ALPHABLENDENABLE, TRUE);
        D3D.SetRS(D3DRS_SRCBLEND, D3DBLEND_BLENDFACTOR);
        D3D.SetRS(D3DRS_DESTBLEND, D3DBLEND_INVBLENDFACTOR);

        // 9 Samples
        for(float f = 0.1f; f <= 1.0f; f += 0.1f)
        {
            // Blendfaktor (Opazität) dieses Samples bestimmen
            DWORD dwFactor = (DWORD)((1.0f - f) * 63.0f);
            D3D.SetRS(D3DRS_BLENDFACTOR, 0xFF000000 | dwFactor | (dwFactor << 8) | (dwFactor << 16));

        }

        D3D.SetRS(D3DRS_ZWRITEENABLE, TRUE);
        D3D.SetRS(D3DRS_ALPHABLENDENABLE, FALSE);
    }

    // ------------------------------------------------------------------

    // Alle Bälle rendern
    for(DWORD dwBall = 0; dwBall < 16; dwBall++)
    {
        if(m_aBall[dwBall].m_bExists)
        {
            // Rendern!
            m_aBall[dwBall].Render(fTime);
        }
    }
    // Szene beenden
    D3D->EndScene();

    return TB_OK;
}

// __________________________________________________________________
// Initialisiert einen Level
tbResult CGame::InitLevel(int iLevel)
{
    // Sound für neuen Level abspielen
    g_pBreakanoid->m_apSound[2]->PlayNextBuffer();

    // Neuen Level setzen
    m_iLevel = iLevel;
    m_bPaused = FALSE;
    m_bGameOver = FALSE;

    //Textur laden
    g_pTerrainTexture = tbTextureManager::Instance().GetTexture("Bubbles.jpg");
    if(g_pTerrainTexture == NULL) return TB_ERROR;

    // Höhendaten einlesen
    float flt_HeightData[WIDTH][HEIGHT];
 
     std::ifstream f_DataFile;
 
     f_DataFile.open("Gebirge.raw", std::ios::binary);
 
     if (f_DataFile.is_open())
     {

        for (int x=0;x< WIDTH;x++)        {

            for (int z=0; z< HEIGHT;z++)           
            {
                cv_Vertices[z*WIDTH + x].vPosition = tbVector3(float(x)-15.0f,f_DataFile.get()/50,float(z)-4.0f);

                cv_Vertices[z*WIDTH + x ].vTexture = tbVector2((((float)(x) / (float)(HEIGHT - 1) - 0.5f) * 200.0f* 0.01f),(((float)(-z) / (float)(HEIGHT - 1) + 0.5f) * 200.0f* 0.01f)) ; 
                
            }
        }
    }else{
        return TB_ERROR;
    }

    f_DataFile.close();

    //Vertexbuffer erstellen
    g_TerrainVertex = new tbVertexBuffer;
    if (g_TerrainVertex->Init(WIDTH*HEIGHT*sizeof(TerrainVertex), sizeof(TerrainVertex), CUSTOMFVF, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DPOOL_DEFAULT ))
     {
        return TB_ERROR;
     }

    // Nun der Index-Buffer (16 Bits pro Index)
    g_TerrainIndex = new tbIndexBuffer;
    if(g_TerrainIndex->Init((WIDTH-1)*(HEIGHT-1)*6 * sizeof(short), sizeof(short), D3DFMT_INDEX16,D3DUSAGE_WRITEONLY, D3DPOOL_MANAGED))
    {
        // Fehler!
        return TB_ERROR;
    }

     // Alle Vertizes eintragen und den Vertex-Buffer aktualisieren
    g_TerrainVertex->AddVertices(WIDTH*HEIGHT, cv_Vertices);
    if(g_TerrainVertex->Update()) return TB_ERROR;

    // Den Index-Buffer ausfüllen
    short s_Indices[(WIDTH-1)*(HEIGHT-1)*6];
 
     for (int x=0;x< WIDTH-1;x++)    {

        for (int y=0; y< HEIGHT-1;y++)        {
            s_Indices[(x+y*(WIDTH-1))*6+2] = x+y*WIDTH;
            s_Indices[(x+y*(WIDTH-1))*6+1] = (x+1)+y*WIDTH;
            s_Indices[(x+y*(WIDTH-1))*6] = (x+1)+(y+1)*WIDTH;

            s_Indices[(x+y*(WIDTH-1))*6+3] = (x+1)+(y+1)*WIDTH;
            s_Indices[(x+y*(WIDTH-1))*6+4] = x+y*WIDTH;
            s_Indices[(x+y*(WIDTH-1))*6+5] = x+(y+1)*WIDTH;

        }
    }

    g_TerrainIndex->AddIndices((WIDTH-1)*(HEIGHT-1)*6, s_Indices);
    if(g_TerrainIndex->Update()) return TB_ERROR;

// __________________________________________________________________
// Erstellt einen neuen Ball
int CGame::CreateBall(tbVector3 vPosition,
                      tbVector3 vVelocity,
                      BOOL bGrabbed)
{
    CBall* pBall;

    // Freien Ball suchen
    for(int iBall = 0; iBall < 16; iBall++)
    {
        pBall = &m_aBall[iBall];

        if(!pBall->m_bExists)
        {
            // Freier Ball gefunden! Ausfüllen!
            // Speicherbereich zurücksetzen.
            ZeroMemory(pBall, sizeof(CBall));

            pBall->m_bExists = TRUE;
            pBall->m_pGame = this;
            pBall->m_vPosition = vPosition;
            pBall->m_vVelocity = vVelocity;

            // Index des neuen Balls liefern
            return iBall;
        }
    }

    // Kein Platz mehr!
    return -1;
}

C-/C++-Quelltext

// Bewegt einen Ball
tbResult CBall::Move(float fTime)
{
    BOOL        bWall;
    tbVector3   vBlock;
    tbVector3   yTerrain;
    float       fDistLeft;
    float       fDistRight;
    float       fDistTop;
    float       fDistBottom;
    float       fMinDist;
    int         iSound;
    int         iBuffer;
    

    // Position verändern
    m_vPosition += m_vVelocity * fTime;

        // Auf die Pfeiltasten reagieren (m_vPaddleVel ändern)
    m_vVelocity.x += g_pfButtons[TB_KEY_RIGHT] * 10.0f * fTime;
    m_vVelocity.x -= g_pfButtons[TB_KEY_LEFT] * 10.0f * fTime;
    m_vVelocity.z += g_pfButtons[TB_KEY_UP] * 10.0f * fTime;
    m_vVelocity.z -= g_pfButtons[TB_KEY_DOWN] * 10.0f * fTime;

    m_KollPos = m_vPosition + tbVector3(-7.0f,0.0f,2.0f);

        // Kollision mit dem Terrain berechnen
    for(DWORD dwTerrain = 0; dwTerrain < WIDTH*HEIGHT; dwTerrain++)
    {       
        
            yTerrain = m_pGame->cv_Vertices[dwTerrain].vPosition;
            

            // Befindet sich der Ball im Kollisionsbereich?
            if((m_KollPos.x + 0.25f >= yTerrain.x - 1.0f &&
               m_KollPos.x - 0.25f <= yTerrain.x + 1.0f &&
               m_KollPos.z + 0.25f >= yTerrain.z - 0.5f &&
               m_KollPos.z - 0.25f <= yTerrain.z + 0.5f))
            {
                //m_vPosition.x += 1.0f;
                m_vPosition.y = yTerrain.y + 0.25f;

            }
    }


    // Kollision mit den Blöcken berechnen
    for(DWORD dwBlock = 0; dwBlock < 64; dwBlock++)
    {
        if(m_pGame->m_aBlock[dwBlock].m_iEnergy > 0)
        {
            vBlock = m_pGame->m_aBlock[dwBlock].m_vPosition;
            
            // Befindet sich der Ball im Kollisionsbereich?
            if(m_vPosition.x + 0.25f >= vBlock.x - 1.0f &&
               m_vPosition.x - 0.25f <= vBlock.x + 1.0f &&
               m_vPosition.z + 0.25f >= vBlock.z - 0.5f &&
               m_vPosition.z - 0.25f <= vBlock.z + 0.5f)
            {

                // Entfernung des Balls von allen Blockseiten berechnen
                fDistLeft = fabsf(m_vPosition.x + 0.25f - (vBlock.x - 1.0f));
                fDistRight = fabsf(m_vPosition.x - 0.25f - (vBlock.x + 1.0f));
                fDistTop = fabsf(m_vPosition.z - 0.25f - (vBlock.z + 0.5f));
                fDistBottom = fabsf(m_vPosition.z + 0.25f - (vBlock.z - 0.5f));

                // Minimale Distanz berechnen
                fMinDist = TB_MIN(fDistLeft, TB_MIN(fDistRight, TB_MIN(fDistTop, fDistBottom)));

                // Wenn die Distanz zur linken oder rechten Seite am kleinsten ist...
                if(fMinDist == fDistLeft || fMinDist == fDistRight)
                {
                    // Ball an der z-Achse abprallen lassen
                    m_vVelocity.x *= -1.0f;
                }
                else
                {
                    // Ball an der x-Achse abprallen lassen
                    m_vVelocity.z *= -1.0f;
                }

                // Kollision ist immer nur mit einem einzigen Block möglich!
                break;
            }
        }
    }

    return TB_OK;
}

// __________________________________________________________________
// Rendert einen Ball
tbResult CBall::Render(float fTime)
{
    tbMatrix mWorld;

    // Ball rendern
    tbDirect3D& D3D = tbDirect3D::Instance();
    D3D.Instance().SetTransform(D3DTS_WORLD, tbMatrixTranslation(GetAbsPosition()));
    m_pGame->m_pBallModel->Render();

    // Motion-Blurring
    if(!m_bGrabbed &&
       D3D.GetCaps().SrcBlendCaps & D3DPBLENDCAPS_BLENDFACTOR)
    {
        // Alpha-Blending aktivieren und verhindern, dass in den Z-Buffer geschrieben wird
        D3D.SetRS(D3DRS_ZWRITEENABLE, FALSE);
        D3D.SetRS(D3DRS_ALPHABLENDENABLE, TRUE);
        D3D.SetRS(D3DRS_SRCBLEND, D3DBLEND_BLENDFACTOR);
        D3D.SetRS(D3DRS_DESTBLEND, D3DBLEND_INVBLENDFACTOR);

        // 9 Samples
        for(float f = 0.1f; f <= 1.0f; f += 0.1f)
        {
            // Blendfaktor (Opazität) dieses Samples bestimmen.
            // Wir lassen ihn von 0 bis 63 reichen.
            DWORD dwFactor = (DWORD)((1.0f - f) * 63.0f);

            // Blendfaktor setzen. Wir kopieren den Wert auf alle Farbkanäle.
            D3D.SetRS(D3DRS_BLENDFACTOR, 0xFF000000 | dwFactor | (dwFactor << 8) | (dwFactor << 16));

            // Position zurückrechnen und Ball rendern
            D3D.Instance().SetTransform(D3DTS_WORLD,
                                        tbMatrixTranslation(GetAbsPosition() - f * m_vVelocity * 0.1f));
            m_pGame->m_pBallModel->Render();
        }

        // Render-States zurücksetzen
        D3D.SetRS(D3DRS_ZWRITEENABLE, TRUE);
        D3D.SetRS(D3DRS_ALPHABLENDENABLE, FALSE);
    }
    return TB_OK;
}