spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

    // Hilfsmakro um COM-Objekte ordentlich freizugeben.

template<typename T> inline void safeRelease (T*& object)
{
        // Ist das Object 'NULL'?

    if (object != NULL)
    {
            // Nein das Object ist noch nicht 'NULL'! Also Freigeben und

            // auf 'NULL' setzen.

        object->Release ();
        object = NULL;
    }
}

// für Freundschaften schonmal bekannt machen

class polygon;
class scenemanager;

// Klasse für Materials

class material
{
public:
        // Constructor, Copyconstructor und Destructor

    material (const ::D3DMATERIAL& material, const ::IDirect3DTexture9*& texture)
    : material_(material), texture_(texture) {}
    material (const material& other)
    : material_(other.material_), texture_(other.texture_) {}
  
    ~material (void)
    { safeRelease (texture_); }

        // Freundschaften

    friend class polygon; // Polygon hat vollzugriff auf private Elemente von material

    friend class scenemanager; // scenemanager hat vollzugriff

private:
        // Materialeingenschaften

    ::D3DMATERIAL        material_; // Material von Direct3D

    ::IDirect3DTexture9* texture_;  // Texturobjekt

};



    // Klasse für Polygone

class polygon
{
public:
        // Constructor und Copyconstructor

    polygon (unsigned long fvf, unsigned long num_vertices, unsigned long num_indices, 
             const ::vertex* vertices_, unsigned long* indices_, const ::material& mat)
    : fvf_(fvf), num_vertices_(num_vertices), num_indices_(num_indices), vertices_(vertices), indices_(indices), material_(mat)
    {
        // CreateVertexBuffer und CreateIndexBuffer ausführen

    }

    polygon (const polygon& other)
    : fvf_(other.fvf_), num_vertices_(other.num_vertices_), num_indices_(other.num_indices_), 
    vertices_(other.vertices_), indices_(other.indices_), material_(other.material_)
    {
        // CreateVertexBuffer und CreateIndexBuffer ausführen

    }

    ~polygon (void)
    {
            // Aufräumen nicht vergessen!

        safeRelease (vb_); // VertexBuffer

        safeRelease (ib_); // Indexbuffer

    }

        // Freundschaften

    friend class scenemanager; // Vollzugriff von scenemanager.


protected:
    unsigned long fvf_;         // Dein FVF

    unsigned long num_vertices_;// Anzahl vertices für dieses Polygon

    unsigned long num_indices_; // Anzahl indices für dieses Polygon

    ::vertex*     vertices_;    // Die Vertices des Polygons

    unsigned long*indices_;     // Die Indices des Polygons


    ::material     material_;      // Das Material


    ::IDirect3DVertexBuffer9* vb_; // VertexBuffer

    ::IDirect3DIndexBuffer9*  ib_; // IndexBuffer

};


    // Der Scenemanager. ACHTUNG: Hier wäre eine Freundschaft zu deiner D3D Klasse sehr hilfreich!

class scenemanager
{
private:
        // Con- und Destructor

    scenemanager  (void);
    scenemanager  (const scenemanager& other);
    ~scenemanager (void);

        // Es gibt nur eine Instanz. Jede Zuweisung wäre eine Selbstzuweisung.

        // Da Selbstzuweisungen selten Sinn machen, ist der op= privat

    scenemanager& operator= (const scenemanager& other);

public:
        // Diese statische Methode erzeugt die einzige Instanz.

        // Nur über diese Methode erhalten Anwender den Zugriff auf

        // die Instanz.

    inline static scenemanager& getInstance (void)
    {
            // Die Instanz wird erst beim ersten Aufruf erzeugt.

            // Endet das Programm, wird Instanz vernichtet.

        static scenemanager instance;
        return (instance);
    }

    void addPolygon (const ::polygon* poly)
    {
            // Polygon in die Liste hinzufügen

        polygon_.push_back (poly);
    }

    void renderAll (void)
    {
            // Alles sortieren!

        sortPolygons ();

            // Alle Polygone durchlaufen lassen

        for (polygon_it_ = polygon_.begin(); polygon_it_ != polygon_.end(); ++polygon_)
        {
                // Textur setzen, falls nötig (Hier sollte ein Texturmanager zum einsatz kommen!! Bringt Speed

            texturemanager::getInstance().setTexture ((*polygon_it_)->material_.texture_);

                // Dein Material setzen

            direct3d::getInstance().setMaterial ((*polygon_it_)->material_.material_);

                // Dein FVF setzen

            direct3d::getInstance().setFVF ((*polygon_it_)->fvf_);

            // VertexBuffer setzen, Indexbuffer setzen, Rendern --> Fertig!

            // [...]

        }

            // Manager für nächsten Frame fertigmachen! Ergo: alle Polygone rauswerfen

        polygon_.clear ();
    }

private:
        // Funktion zum sortieren der Polygone

    void sortPolygons (void)
    {
        // Hier nach Texturnamen sortieren.

    }

        // Das wichtigste vom Wichtigsten

    std::list<polygon*>           polygon_;    // Liste für Polygone

    std::list<polygon*>::iterator polygon_it_; // Iterator für Polygonliste

}










Benutzung:

     // Bei beginn des Programms ein Polygon erstellen

polygon poly (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_XXX, anzahl_vertices, anzahl_indices, 
              vertexpointer, indexpointer, ::material (irgendein_d3dmaterial, dein_texturobjekt));

// Hauptschleife

{
    if (sichtbar(poly))
        scenemanager::getInstance().add(&poly);

    scenemanager::getInstance().renderAll();
}

C-/C++-Quelltext

#include <iostream>
#include <string>
#include <list>
#include <algorithm>

class person 
{ 
public:
    person (std::basic_string<wchar_t> value) : name(value) {};

    std::basic_string<wchar_t> name; 
};

bool compareByName(const person& left, const person& right) 
{ 
  return left.name < right.name; 
}

int main (void)
{
    std::list<person> pers;
    std::list<person>::iterator pers_it;

    pers.push_back (person(L"alfred"));
    pers.push_back (person(L"alfonso"));
    pers.push_back (person(L"jehova"));
    pers.push_back (person(L"peter"));
    pers.push_back (person(L"alfonso"));
    pers.push_back (person(L"bernd"));
    pers.push_back (person(L"pikaboo"));
    pers.push_back (person(L"peter"));
    pers.push_back (person(L"peter"));
    pers.push_back (person(L"alfonso"));
    pers.push_back (person(L"buddha"));
    pers.push_back (person(L"jehova"));
    pers.push_back (person(L"bernd"));
    pers.push_back (person(L"alfonso"));
 
    pers.sort(compareByName);

    for (pers_it = pers.begin(); pers_it != pers.end(); ++pers_it)
    {
        std::wcout <<  pers_it->name << std::endl;
    }
    
    std::cin.get();

    return 0;
}