spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// Datei:           Types.h
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        19.11.03
// Änderungen:     19.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Diverse Dateitypdefinitionen und Makros

#ifndef _TYPES_H_
#define _TYPES_H_

// I N C L U D E S //////////////////////////////////////////////////////////////////
    // Bei Win32 muss die Windows.h includiert werden!
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif

    // Standardheader für das Programm (ACHTUNG: Alle _ohne_ Endung *.h)
#include <string>
#include <sstream>
#include <fstream>
#include <iostream>
#include <cmath>
#include <vector>

    // SDL und OpenGL includieren
#include <SDL\SDL.h>
#include <GL\gl.h>
#include <GL\glu.h>

// L I N K E R //////////////////////////////////////////////////////////////////////
    // Windows kann diese Libs selbst linken, sonst muss man manuel dran.
#ifdef _WIN32
#pragma comment(lib, "SDL.lib")
#pragma comment(lib, "SDLmain.lib")
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#endif

// D E F I N I T I O N E N //////////////////////////////////////////////////////////
    // Diese Dateitypen sind normalerweise in der windef.h drin, wir nehmen aber aus
    // Portablen Gründen unsere eigenen Definitionen, die denen aus 
    // der Windef.h entsprechen.
typedef unsigned long       DWORD;
typedef unsigned short      WORD;
typedef unsigned char       BYTE;
typedef unsigned char       byte;
typedef unsigned int        UINT;

    // PI ist sehr wichtig!!
const float PI = 3.1415926535897932f;

    // Bei Win32 muss man die definition von main aufheben wegen SDL
#ifdef _WIN32
#undef main
#endif

// M A K R O S //////////////////////////////////////////////////////////////////////
    // Manche Compiler kennen dieses Makro nicht, drum selbst definieren.
#ifndef __FUNCTION__
#define __FUNCTION__ ("unknowFunction")
#endif

    // Da ich ne faule Sau bin benutz ich dieses Makro einfach mal :D
#ifndef LOG_PARAMS
#define LOG_PARAMS __FILE__, __LINE__, __FUNCTION__
#endif

#ifndef PROTOKOLL
#define PROTOKOLL CLog::getInstance()
#endif

#ifndef VIDEO
#define VIDEO CVideo::getInstance()
#endif

#ifndef KEYBOARD
#define KEYBOARD CKeyboardManager::getInstance()
#endif

#ifndef TEXTUREMANAGER
#define TEXTUREMANAGER CTextureManager::getInstance()
#endif

// F U N K T I O N E N //////////////////////////////////////////////////////////////
    // Noch keine

// S T R U K T U R E N //////////////////////////////////////////////////////////////
    // Noch keine

#endif

Quellcode

// Datei:           CTextureManager.h
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        19.11.03
// Änderungen:     19.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Manager für Texturen

#ifndef _CTEXTUREMANAGER_H_
#define _CTEXTUREMANAGER_H_

// I N C L U D E S //////////////////////////////////////////////////////////////////
#include "CLog.h"

// S T R U K T U R E N //////////////////////////////////////////////////////////////
class CTextureManager
{
public:
    static CTextureManager*     getInstance     (void);
    static void                 destroyInstance (void);

        // Läd eine BMP in den Texturmanager.
    void            loadTexture         (std::string FileName);

        // Gibt die Textur zurück.
    GLuint          getTexture          (std::string FileName);
    GLuint          getTexture          (int ID);

        // Gibt die Texturnummer zurück.
    int             getTextureID        (std::string FileName);

        // Gibt die Anzahl der Texturen zurück.
    int             getNumTextures      (void);

        // Leert den Texturmanager.
    void            clear               (void);

        // Löscht eine Bestimmte Textur aus dem Manager.
    void            clearTexture        (std::string FileName);
    void            clearTexture        (int ID);


private:
        // Constructor
    CTextureManager                     (void);
        // Destructor
    ~CTextureManager                    (void);

        // Die Instance
    static CTextureManager*             m_instance;

        // Die Struktur für den Vector
    class TextureItem
    {
    public:
        GLuint      texID;
        std::string FileName;
    };

        // Der Texturvector
    std::vector<TextureItem>            m_vec_Textures;
};

#endif

Quellcode

// Datei:           CTextureManager.cpp
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        19.11.03
// Änderungen:     19.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Manager für Texturen

// I N C L U D E S //////////////////////////////////////////////////////////////////
#include "CTextureManager.h"

// D E F I N I T I O N E N //////////////////////////////////////////////////////////
        // Die einzig mögliche Instance
CTextureManager* CTextureManager::m_instance = 0;

// F U N K T I O N E N //////////////////////////////////////////////////////////////

// /////////////////////////////////////////////////
// PRIVATE Constructor
//
// /////////////////////////////////////////////////
CTextureManager::CTextureManager (void)
{
}

// /////////////////////////////////////////////////
// PRIVATE Destructor
//
// /////////////////////////////////////////////////
CTextureManager::~CTextureManager (void)
{
    this->m_vec_Textures.clear ();
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Gibt eine gültige Instance des Singletons zurück.
//
// [ret] Die Instance des Singletons
// /////////////////////////////////////////////////
CTextureManager* CTextureManager::getInstance (void)
{
        // Existiert die Instance des Managers?
    if (m_instance == NULL)
    {
            // Wenn nein, neue Instance anlegen.
        m_instance = new CTextureManager;
    }

        // Instance zurück geben.
    return m_instance;
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Vernichtet die Instance des Singletons
// /////////////////////////////////////////////////
void CTextureManager::destroyInstance(void)
{
        // Existiert die Instance?
    if (m_instance)
    {
            // Ja sie exisitert -> löschen.
        delete m_instance;
        m_instance = NULL;
    }
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Läd eine Bitmap in den Texturmanager.
//
// [in] FileName: Name der zu ladenen Bitmap
// /////////////////////////////////////////////////
void CTextureManager::loadTexture (std::string FileName)
{
        // Teste ob Textur schon geladen
    if (!(getTexture (FileName) == -1))
        return;

        // Teste ob datei überhaupt existiert.
    std::ifstream FileStream(FileName.c_str()); 

    if (!FileStream.good()) 
    {
            // Datei existiert nicht, Warnung ins Protokoll schreiben.
        PROTOKOLL->write (MESSAGE_FILENOTFOUND(FileName, LOG_PARAMS));

            // Und Funktion abbrechen.
        return;
    }

        // Temporäres Objekt anlegen und namen geben.
    TextureItem temp;
    temp.FileName = FileName;

        // Bitmap in SDL-Surface laden.
    SDL_Surface *Texture(SDL_LoadBMP(FileName.c_str())); 

        // Textur für OpenGL generieren.
    glGenTextures(1, &temp.texID); 
    glBindTexture(GL_TEXTURE_2D, temp.texID); 
    glTexImage2D(GL_TEXTURE_2D, 0, 3, Texture->w, Texture->h, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, Texture->pixels); 

        // SDL-Surface wieder freigeben und auf NULL setzen.
    if (Texture != NULL)
    {
        SDL_FreeSurface(Texture); 
        Texture = NULL;
    }

        // Noch einen Linearen Filter reinhauen
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 

        // und ab damit in den Vector pushen.
    this->m_vec_Textures.push_back (temp);
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Gibt eine Textur zurück.
//
// [in] FileName: Name der Textur.
//
// [ret] Die Textur oder -1 wenn die Textur nicht
//       vorhanden ist.
// /////////////////////////////////////////////////
GLuint CTextureManager::getTexture (std::string FileName)
{
        // Durchlaufe den Vector
    for (std::vector<TextureItem>::iterator it=this->m_vec_Textures.begin(); it<this->m_vec_Textures.end(); ++it)
    {
            // Hat eine Textur im Vector den selben Namen wie angefordert?
        if (it->FileName == FileName)
        {
                // Wenn ja, Textur zurückgeben, ansonsten weitersuchen.
            return (it->texID);
        }
    }
        // Wenn die Funktion bis hier hin kommt, ist die Textur nicht vorhanden.
        // Drum geben wir -1 zurück
    return -1;
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Gibt eine Textur zurück.
//
// [in] ID: Position der Textur im Vector.
//
// [ret] Die Textur 
// /////////////////////////////////////////////////
GLuint CTextureManager::getTexture (int ID)
{
        // Gib die Textur zurück
    return (this->m_vec_Textures[ID].texID);
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Gibt die Textur Position zurück.
//
// [in] FileName: Name der Textur.
//
// [ret] Die Textur Position.
// /////////////////////////////////////////////////
int CTextureManager::getTextureID (std::string FileName)
{
        // Durchlaufe den Vector
    for (int i=0; i<static_cast<int>(this->m_vec_Textures.size()); ++i)
    {
            // Hat eine Textur im Vector den selben Namen wie angefordert?
        if (this->m_vec_Textures[i].FileName == FileName)
        {
                // Wenn ja geben wir die Position zurück, ansonsten weiterversuchen.
            return (i);
        }
    }

        // Wenn die Funktion bis hier hin kommt, ist die Textur nicht vorhanden.
        // Drum geben wir -1 zurück.
    return -1;
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Gibt eine Anzahl der Texturen zurück.
//
// [ret] Anzahl der Texturen.
// /////////////////////////////////////////////////
int CTextureManager::getNumTextures (void)
{
        // Gib die größe des Vectors zurück.
    return (static_cast<int>(this->m_vec_Textures.size()));
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Leert den Texturmanager
// /////////////////////////////////////////////////
void CTextureManager::clear (void)
{
        // Alle Texturen im Vector rauswerfen.
    this->m_vec_Textures.clear ();
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Löscht eine Textur aus dem Texturmanager.
//
// [in] FileName: Name der Textur.
// /////////////////////////////////////////////////
void CTextureManager::clearTexture (std::string FileName)
{
        // Durchlaufe den Vector
    for (std::vector<TextureItem>::iterator it=this->m_vec_Textures.begin(); it<this->m_vec_Textures.end(); ++it)
    {
            // Hat eine Textur im Vector den selben Namen wie angefordert?
        if (it->FileName == FileName)
        {
                // Wenn ja, löschen, ansonsten weitersuchen.
            this->m_vec_Textures.erase (it);
        }
    }

    // Wenn die Funktion bis hier hin kommt, ist die Textur nicht vorhanden.
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Löscht eine Textur aus dem Texturmanager.
//
// [in] ID: Position der Textur.
// /////////////////////////////////////////////////
void CTextureManager::clearTexture (int ID)
{
        // Wenn ja, löschen, ansonsten weitersuchen.
    this->m_vec_Textures.erase (&this->m_vec_Textures[ID]);
}

Quellcode

// Datei:           Sample.cpp
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        19.11.03
// Änderungen:     19.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Sample Datei

// I N C L U D E S //////////////////////////////////////////////////////////////////
#include "sample.h"

// F U N K T I O N E N //////////////////////////////////////////////////////////////
CFont Font;
// /////////////////////////////////////////////////
// GLOBAL 
//
// Funktion zum laden des Samples.
// /////////////////////////////////////////////////
void SampleLoad (void)
{
        // Textur für das Rotierende Rechteckt laden
    TEXTUREMANAGER->loadTexture ("data\\gfx\\rect.bmp");

        // Textur für das X laden
    TEXTUREMANAGER->loadTexture ("data\\gfx\\x.bmp");

    Font.init ("data\\gfx\\font.bmp");
}

// /////////////////////////////////////////////////
// GLOBAL 
//
// Funktion zum abspielen des Samples.
// /////////////////////////////////////////////////
void SampleRun  (void)
{
        // Backbuffer mit Schwarz leeren.
    VIDEO->clear (0.0f, 0.0f, 0.0f);

        // Alles resetten
    glLoadIdentity (); 

        // Matrix für das Rotierende Objekt pushen.
    glPushMatrix ();
    {
            // Objekt an die Position 0,0,-5 Transformieren.
        glTranslatef (0.0f, 0.0f, -5.0f); 

            // Statische Variable für Rotation anlegen.
        static float degree = 0; 
     
            // ist degree über 360° dann wieder auf 0 setzen.
        if(degree > 360.0f) 
        {
            degree = 0.0f; 
        }
        else  
        {
                // Ansonsten 1° drauf rechnen.
            degree++; 
        }
 
            // Rotieren auf jeder Achse
        glRotatef (degree, 1.0f, 1.0f, 1.0f); 
     
            // 2D Textur Aktivieren
        glEnable (GL_TEXTURE_2D); 
            // 2D Textur setzen
        glBindTexture (GL_TEXTURE_2D, TEXTUREMANAGER->getTexture ("data\\gfx\\rect.bmp")); 
 
            // Rechteck rendern
        glBegin (GL_QUADS); 
        {
            glTexCoord2f (0.0f, 0.0f); 
            glVertex3f (-1.0f, -1.0f, 0.0f);

            glTexCoord2f (1.0f, 0.0f); 
            glVertex3f (1.0f, -1.0f, 0.0f);

            glTexCoord2f (1.0f, 1.0f); 
            glVertex3f (1.0f, 1.0f, 0.0f);

            glTexCoord2f (0.0f, 1.0f); 
            glVertex3f (-1.0f, 1.0f, 0.0f);
        }
        glEnd (); 
        
            // 2D Textur deaktivieren
        glDisable (GL_TEXTURE_2D); 
    }
        // Matrix für das Objekt poppen.
    glPopMatrix ();




        // Matrix für das Statische Objekt pushen.
    glPushMatrix ();
    {
            // Objekt an die Position 0,0,-3 Transformieren.
        glTranslatef (0.0f, 0.0f, -3.0f); 
     
            // Blending aktivieren
        glEnable (GL_BLEND);
        
            // Graustufen Alphalbending aktivieren
        glBlendFunc (GL_SRC_ALPHA, GL_ONE);

            // 2D Textur Aktivieren
        glEnable (GL_TEXTURE_2D); 

            // 2D Textur setzen
        glBindTexture (GL_TEXTURE_2D, TEXTUREMANAGER->getTexture ("data\\gfx\\x.bmp")); 
 
            // Rechteck rendern
        glBegin (GL_QUADS); 
        {
            glTexCoord2f (0.0f, 0.0f); 
            glVertex3f (-1.0f, -1.0f, 0.0f);

            glTexCoord2f (1.0f, 0.0f); 
            glVertex3f (1.0f, -1.0f, 0.0f);

            glTexCoord2f (1.0f, 1.0f); 
            glVertex3f (1.0f, 1.0f, 0.0f);

            glTexCoord2f (0.0f, 1.0f); 
            glVertex3f (-1.0f, 1.0f, 0.0f);
        }
        glEnd (); 

            // Blending deaktivieren
        glDisable (GL_BLEND);

            // 2D Textur deaktivieren
        glDisable (GL_TEXTURE_2D); 
    }
        // Matrix für das Objekt poppen.
    glPopMatrix ();


        // Roten normalen Text renndern:
    glColor3f (1.0f, 0.0f, 0.0f);
    Font.print (10, 30, "Tutorial 2: Loading Bitmaps", false);

        // Weißen kursiven Text rendern:
    glColor3f (1.0f, 1.0f, 1.0f);
    Font.print (10, 10, "Tutorial 2: Loading Bitmaps", true);


        // Und auf den Monitor hauen
    VIDEO->present ();
}