glcanvas.cpp

/***************************************************************************
                           glcanvas.cpp
                           -------------------
    begin                : 2004-05-24 22:19
    copyright            : (C) 2004-2005 by Michael Menne
    email                : menne@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 ***************************************************************************/

#include "glcanvas.h"
#include "app.h"
#include "texture.h"
#include "map.h"
#include <wx/tooltip.h>
#include <stdio.h>
#include <math.h>

extern ofstream logFile;

namespace WDS
{

// Breiten der jeweiligen Buchstaben
static int g_aGlyphWidths[256] =
{  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   4,  5,  6,  9,  9, 14, 11,  3,  5,  5,  6,  9,  4,  5,  4,  4,
   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  4,  4,  9,  9,  9,  9,
  16, 11, 11, 12, 12, 11, 10, 12, 11,  3,  8, 11,  9, 13, 11, 12,
  11, 12, 11, 11,  9, 11, 11, 15, 11,  9,  9,  4,  4,  4,  7,  9,
   5,  9,  9,  8,  9,  9,  4,  9,  8,  4,  3,  8,  3, 13,  8,  9,
   9,  9,  5,  8,  4,  8,  7, 11,  7,  7,  7,  5,  3,  5,  9, 12,
  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   4,  5,  9,  9,  9,  9,  3,  9,  5, 12,  5,  9,  9,  5, 12,  9,
   6,  9,  5,  5,  5,  9,  9,  4,  5,  5,  5,  9, 13, 13, 13, 10,
  11, 11, 11, 11, 11, 11, 16, 12, 11, 11, 11, 11,  3,  3,  3,  3,
  12, 11, 12, 12, 12, 12, 12,  9, 12, 11, 11, 11, 11,  9, 11,  9,
   9,  9,  9,  9,  9,  9, 14,  8,  9,  9,  9,  9,  3,  3,  3,  3,
   9,  8,  9,  9,  9,  9,  9,  9,  9,  8,  8,  8,  8,  7,  9,  7
};

// Message map
BEGIN_EVENT_TABLE(CGLCanvas, wxGLCanvas)
    EVT_SIZE(CGLCanvas::OnSize)
    EVT_PAINT(CGLCanvas::OnPaint)
    EVT_ERASE_BACKGROUND(CGLCanvas::OnEraseBackground)
    EVT_KEY_DOWN( CGLCanvas::OnKeyDown )
    EVT_MOTION( CGLCanvas::OnMouseMove )
    EVT_LEFT_DOWN( CGLCanvas::OnLButtonDown )
    EVT_LEFT_UP( CGLCanvas::OnLButtonUp )
    EVT_SCROLLWIN( CGLCanvas::OnScrollBar )
    EVT_TIMER( 1, CGLCanvas::OnTimer )
END_EVENT_TABLE()

/*----------------------------------------------------------------------------/
    Constructor / Destructor
-----------------------------------------------------------------------------*/

CGLCanvas::CGLCanvas( wxWindow *parent) : wxGLCanvas(parent, (wxGLCanvas*) NULL ),
  m_timer(this, 1), m_pFont(0)
{
    m_XPos = 0;
    m_YPos = 0;
    m_fZoom = 1.0f;

    m_Width = 0;
    m_Height = 0;

#ifdef SHOW_TOOLTIPS
    SetToolTip( "Text..." );    // Wichtig!
#endif
}

CGLCanvas::~CGLCanvas( )
{
    // Textur der Font freigeben
    DeleteTexture( m_pFont );

    // Alle noch nicht geloeschten Texturen freigeben
    TexMap::iterator i = m_aTextures.begin();
    for( ; i!=m_aTextures.end(); i++ )
    {
        CTexture *pTex = i->second;
        logFile << "Texture '" << pTex->GetName() << "' still has a RefCount of "
                << pTex->GetRefCount() << "." << endl;
        delete pTex;
    }
    m_aTextures.clear();    // Alle Eintraege loeschen
}

/*----------------------------------------------------------------------------/
    Member Functions
-----------------------------------------------------------------------------*/

void CGLCanvas::Init()
{
    if (!GetContext())
    {
        cout << "***ERROR: GLCanvas::Init: Kein OpenGL Kontext!" << endl;
        return;
    }
    SetCurrent();

    // Groesse des Fensters abfragen und Viewport setzen
    GetClientSize(&m_Width, &m_Height);
    glViewport(0, 0, (GLint) m_Width, (GLint) m_Height);

    // Create Ortho View (0,0 At Top Left)
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glOrtho( 0.0f, m_Width, m_Height, 0.0f, 0.0f, 10.0f);
    glMatrixMode( GL_MODELVIEW );

    // Texturing einschalten
    glEnable(GL_TEXTURE_2D);

    glDisable( GL_DEPTH_TEST );
    glCullFace( GL_BACK );

    // Clear Color
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    // Alpha testing
    glEnable( GL_ALPHA_TEST );
    glAlphaFunc(GL_GREATER, 0.7f);

    // Alpha blending
    //glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // Font Textur laden
    m_pFont = LoadTexture( "data/font.png", false );

    // Clear screen
    glClear( GL_COLOR_BUFFER_BIT );
    SwapBuffers();
}

void CGLCanvas::UpdateView( )
{
    ClampView( );
    Refresh( );
}

void CGLCanvas::OnPaint( wxPaintEvent& event )
{
    wxPaintDC dc(this); // Muss vorhanden sein!
    if (!GetContext())
    {
        cout << "***ERROR: GlCanvas::OnPaint: Kein Kontext" << endl;
        return;
    }
    SetCurrent();

    // clear color buffers
    glClear( GL_COLOR_BUFFER_BIT );
    glLoadIdentity();                  // reset the view before we draw

    // Zeiger auf Karte holen
    CMap *pMap = wxGetApp().GetMap();

    if( pMap )
    {
        glTranslatef( -m_XPos, -m_YPos, 0.0f ); // scroll
        glScalef( m_fZoom, m_fZoom, 1.0f );     // zoom

        // Karte zeichnen
        pMap->Draw();

        // Sichtbares Rechteck zeichnen
        //Rect r2 = GetVisibleRect();
        //this->DrawRect( &r2, 1.0f,0.0f, 0.0f );

        // Rechteck um Karte zeichnen
        Rect rcMap = pMap->GetBounds();
        this->DrawRect( rcMap, 1.0f, 0.0f, 0.0f );
    }
    else
    {
        // Keine Karte geladen - Nachricht ausgeben
        wxString strNoMap = "No map loaded!";

        wxRect  rcClient = GetClientRect( );
        wxPoint ptExtent = GetTextExtent( strNoMap.c_str() );

        int x = rcClient.GetRight()  / 2 - ptExtent.x / 2;
        int y = rcClient.GetBottom() / 2 - ptExtent.y / 2;

        // Text zentriert auf dem Bildschirm ausgeben
        DrawText( x, y, 1.0f, 0.0f, 0.0f, 1.0f, strNoMap.c_str() );
    }

    glFlush();
    SwapBuffers();
}

void CGLCanvas::OnSize( wxSizeEvent &event )
{
    if (!GetContext())
    {
        //cout << "***ERROR: GlCanvas::OnSize: Kein Kontext" << endl;
        return;
    }
    SetCurrent();

    // set GL viewport (not called by wxScrolledGLCanvas::OnSize on all platforms...)
    m_Width  = event.GetSize().GetWidth();
    m_Height = event.GetSize().GetHeight();

    glViewport(0, 0, (GLint) m_Width, (GLint) m_Height);

    // Create Ortho View (0,0 At Top Left)
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glOrtho( 0.0f, m_Width, m_Height, 0.0f, 0.0f, 10.0f);
    glMatrixMode( GL_MODELVIEW );

    ClampView();

    // this is also necessary to update the context on some platforms
    // NOTE: on wxGTK wxGLCanvas::OnSize() is empty!
    wxGLCanvas::OnSize(event);

    // HACK: make resizing work for wxGTK.
    m_timer.Start( 100, true );
}

void CGLCanvas::OnTimer( wxTimerEvent &event)
{
    // Neuzeichnen um Repaint-Bug in Linux zu umgehen
    Refresh();
}

void CGLCanvas::OnEraseBackground(wxEraseEvent& event)
{
    // Do nothing, to avoid flashing.
}

/*
 *  OnKeyDown( )
 *  Scrollt die Karte wenn eine Pfeiltaste gedrckt wird
 */
void CGLCanvas::OnKeyDown( wxKeyEvent &event )
{
    const int nMove = 20;

    // Scrollen wenn Pfeiltasten gedrueckt werden
    switch( event.GetKeyCode() )
    {
    case WXK_LEFT:  ScrollREL( -nMove,      0 ); break;
    case WXK_RIGHT: ScrollREL(  nMove,      0 ); break;
    case WXK_UP:    ScrollREL(      0, -nMove ); break;
    case WXK_DOWN:  ScrollREL(      0,  nMove ); break;

    default:
        event.Skip( );  // Weiter an Frame
        break;
    }
}

void CGLCanvas::OnLButtonDown( wxMouseEvent &event )
{
    CaptureMouse();

    // Verhindert sprunghaftes scrollen, wenn die Canvas eine Zeit lang
    // keine Mausevents bekommen hat ( z.B. wegen Kontextmenue )
    m_ptMouseOld = event.GetPosition( );

    event.Skip( );  // Event weiterreichen an CFrame
}

void CGLCanvas::OnLButtonUp( wxMouseEvent &event )
{
    // Nur Maus freigeben, wenn wir sie auch haben!
    if( GetCapture() == this )
        ReleaseMouse();

    event.Skip( );  // Event weiterreichen an CFrame
}

void CGLCanvas::OnMouseMove( wxMouseEvent &event )
{
    // Scrollen wenn die linke Maustaste gedrckt ist
    if( event.LeftIsDown() )
    {
        int dx = m_ptMouseOld.x - event.GetX();
        int dy = m_ptMouseOld.y - event.GetY();

        if( dx != 0 || dy != 0 )
            ScrollREL( dx, dy );
    }

    // Alte Mausposition merken
    m_ptMouseOld = event.GetPosition( );


    event.Skip( );  // Event weiterreichen an CFrame
}

/*
 *  ClampView
 *  Stellt sicher, das der sichtbare Bereich immer innerhalb der Karte liegt.
 *  Wenn der sichtbare Bereich groesser als die Karte ist, wird die Karte zentriert.
 */
void CGLCanvas::ClampView()
{
    // Zeiger auf Karte holen
    CMap *pMap = wxGetApp().GetMap();
    if( pMap == NULL )
        return;     // Keine Karte geladen

    Rect rcMap = pMap->GetBounds();

    // Horizontal
    if( (rcMap.w * m_fZoom) > m_Width )
    {
        // Karte kleiner als sichtbarer Bereich
        if( m_XPos < rcMap.Left() * m_fZoom )                   // Linker Rand
            m_XPos = (int)(rcMap.Left() * m_fZoom);
        else if( m_XPos > (rcMap.Right() * m_fZoom - m_Width) ) // Rechter Rand
            m_XPos = (int)(rcMap.Right() * m_fZoom - m_Width);
    }
    else
    {
        // Karte ist groesser als sichtbarer Bereich, deshalb Karte horizontal zentrieren
        m_XPos = (int)(((rcMap.w * m_fZoom) - m_Width) / 2.0f + rcMap.Left() * m_fZoom);
    }

    // Vertical
    if( (rcMap.h * m_fZoom) > m_Height )
    {
        // Karte kleiner als sichtbarer Bereich
        if( m_YPos < rcMap.Top() * m_fZoom )                            // Oberer Rand
            m_YPos = (int)(rcMap.Top() * m_fZoom);
        else if( m_YPos > (rcMap.Bottom() * m_fZoom - m_Height) )   // Unterer Rand
            m_YPos = (int)(rcMap.Bottom() * m_fZoom - m_Height);
    }
    else
    {
        // Karte ist groesser als sichtbarer Bereich, deshalb Karte vertikal zentrieren
        m_YPos = (int)(((rcMap.h * m_fZoom) - m_Height) / 2.0f);
    }
}

void CGLCanvas::ClientToOpenGL( int &x, int &y )
{
    x = (int)((x + m_XPos) / m_fZoom);
    y = (int)((y + m_YPos) / m_fZoom);
}

void CGLCanvas::OpenGLToClient( int &x, int &y )
{
    x = (int)((x * m_fZoom ) - m_XPos);
    y = (int)((y * m_fZoom ) - m_YPos);
}

void CGLCanvas::OnScrollBar( wxScrollWinEvent &event)
{
    /*int x, y;
    CalcScrolledPosition( 0, 0, &x, &y );

    CMap *pMap = wxGetApp().GetMap();
    Rect rcBounds = pMap->GetBounds();

    m_XPos = -x + rcBounds.Left() * m_fZoom;
    m_YPos = -y + rcBounds.Top()  * m_fZoom;

    ClampView();*/

    event.Skip( );
}


/*
 *  ScrollREL( )
 *  Scrollt um die gegebene Pixelzahl
 */
void CGLCanvas::ScrollREL( int dx, int dy )
{
    m_XPos += dx;
    m_YPos += dy;

    ClampView();

    Refresh( false );
}

/*
 *  ScrollTo( )
 *  Scrollt zu der in Pixeln gegebenen Position
 */
void CGLCanvas::ScrollTo( int x, int y )
{
    m_XPos = (int)((x*m_fZoom) - (m_Width  / 2.0f));
    m_YPos = (int)((y*m_fZoom) - (m_Height / 2.0f));
    ClampView( );
    Refresh( );
}

/*
 *  ZoomIn( )
 *  Zoomt in das Bild
 */
void CGLCanvas::ZoomIn()
{
    SetZoom( m_fZoom + 0.1f );
}

/*
 *  ZoomOut( )
 *  Zoomt aus dem Bild heraus
 */
void CGLCanvas::ZoomOut()
{
    SetZoom( m_fZoom - 0.1f );
}

/*
 *  SetZoom( )
 *  Setzt den aktuellen Zoom auf fZoom und passt den sichtbaren Bereich an
 */
void CGLCanvas::SetZoom( float fZoom )
{
    // Sicherstellen das der Zoom im gueltigen Bereich liegt
    if( fZoom < 0.1f ) fZoom = 0.1f;
    if( fZoom > 4.0f ) fZoom = 4.0f;

    // Delta bestimmen
    float fDelta = fZoom / m_fZoom;
    if( fDelta == 1.0f )    // Bei 1.0f hat sich nichts veraedert
        return;

    // Sichtbaren Bereich anpassen
    m_XPos += (int)((m_Width  * fDelta - m_Width)  / 2.0f + (m_XPos * fDelta - m_XPos));
    m_YPos += (int)((m_Height * fDelta - m_Height) / 2.0f + (m_YPos * fDelta - m_YPos));
    m_fZoom = fZoom;

    // Neu zeichnen
    ClampView();
    Refresh( false );
}

/*
 *  Gibt den zur Zeit sichtbaren Ausschnitt zurueck
 */
Rect CGLCanvas::GetVisibleRect()
{
    Rect rcScreen( (int)(m_XPos  * (1/m_fZoom)), (int)(m_YPos   * (1/m_fZoom)),
                   (int)(m_Width * (1/m_fZoom)), (int)(m_Height * (1/m_fZoom)) );
    return rcScreen;
}

/*-----------------------------------------------------------------------------
    Drawing functions
-----------------------------------------------------------------------------*/

void CGLCanvas::BeginDraw( float r, float g, float b, float a )
{
    glPushAttrib( GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT );
    glBindTexture( GL_TEXTURE_2D, 0 );  // Textur abwaehlen
    glDisable( GL_ALPHA_TEST );         // Alphatesting ausschalten

    // Alphablending anschalten, wenn Alpha < 1
    if( a < 1.0f )
        glEnable( GL_BLEND );

    glColor4f( r, g, b, a );
}

void CGLCanvas::EndDraw( )
{
    glPopAttrib( );
}

void CGLCanvas::FillRect( const Rect &rcRect, float r, float g, float b, float a )
{
    BeginDraw( r, g, b, a );
    glRecti( rcRect.x, rcRect.y, rcRect.Right(), rcRect.Bottom() );
    EndDraw( );
}

void CGLCanvas::DrawRect( const Rect &rcRect, float r, float g, float b, float a )
{
    BeginDraw( r, g, b, a );
    glBegin( GL_LINE_LOOP );
        glVertex2i( rcRect.Left(),  rcRect.Top()    );  // Links oben
        glVertex2i( rcRect.Left(),  rcRect.Bottom() );  // Links unten
        glVertex2i( rcRect.Right(), rcRect.Bottom() );  // Rechts unten
        glVertex2i( rcRect.Right(), rcRect.Top()    );  // Rechts oben
    glEnd();
    EndDraw( );
}

void CGLCanvas::DrawCircle( const wxPoint &ptCenter, int n, float radius,
                           float r, float g, float b, float a)
{
    BeginDraw( r, g, b, a );
    glBegin( GL_POLYGON );
    {
        float step = 2*PI/n;
        for( int i=0; i<n; i++ )
        {
            float r = i * step;
            int x = (int)( cos( r ) * radius ) + ptCenter.x;
            int y = (int)( sin( r ) * radius ) + ptCenter.y;

            glVertex2i( x, y );
        }
    }
    glEnd();
    EndDraw();
}

void CGLCanvas::DrawLine( const wxPoint &pt1, const wxPoint &pt2, float width,
                         float r, float g, float b, float a )
{
    BeginDraw( r, g, b, a );
    glLineWidth( width );       // Zuruecksetzen?
    glBegin( GL_LINES );
    {
        glVertex2i( pt1.x, pt1.y );
        glVertex2i( pt2.x, pt2.y );
    }
    glEnd();
    EndDraw();
}

/*-----------------------------------------------------------------------------
    Font functions
-----------------------------------------------------------------------------*/

/*
 *  DrawTextBox( )
 *  Zeichnet einen ganze String in eine graue Box
 */
void CGLCanvas::DrawTextBox( int x, int y, float r, float g, float b, float a, const char *szText )
{
    if( m_pFont == NULL || szText == NULL )
        return;

    wxPoint pt = GetTextExtent( szText );
    Rect rcFill( x-2, y-2, pt.x+8, pt.y+2 );

    FillRect( rcFill, 0.0f, 0.0f, 0.0f, 0.75f );
    DrawText( x, y, r, g, b, a, szText );
}

/*
 *  DrawText( )
 *  Zeichnet einen ganze String and die gegebene Position
 */
void CGLCanvas::DrawText( int x, int y, float r, float g, float b, float a, const char *fmt, ...)
{
    if( m_pFont == NULL || fmt == NULL )
        return;

    char        szText[1024];                               // Holds Our String
    va_list     ap;                                         // Pointer To List Of Arguments

    va_start(ap, fmt);                                      // Parses The String For Variables
        vsprintf(szText, fmt, ap);                          // And Converts Symbols To Actual Numbers
    va_end(ap);                                             // Results Are Stored In Text

    // Font binden
    m_pFont->Bind();

    // OpenGL Farbe merken
    glPushAttrib( GL_CURRENT_BIT ); // GL_ENABLE_BIT fuehrt zu Fehlern in Linux!
    glColor4f( r, g, b, a );

    // Merken, was an/aus war da glPushAttrib in Linux nicht mit GL_ENABLE_BIT
    // geht -> Resize bug
    GLboolean bAlphaTest  = glIsEnabled( GL_ALPHA_TEST );
    GLboolean bAlphaBlend = glIsEnabled( GL_BLEND );

    // Alphatest ausschalten und alphablend einschalten
    if(  bAlphaTest ) glDisable( GL_ALPHA_TEST );
    if( !bAlphaBlend) glEnable ( GL_BLEND );

    // Text zeichnen
    for(int i=0; szText[i]; i++)
    {
        DrawChar( x, y, szText[i] );
        x += g_aGlyphWidths[((unsigned char)szText[i])];
    }

    // Ausganszustand wieder herstellen
    if(  bAlphaTest  ) glEnable ( GL_ALPHA_TEST );
    if( !bAlphaBlend ) glDisable( GL_BLEND );

    glPopAttrib( );
}

/*
 *  DrawChar( )
 *  Zeichnet ein einzelnes Zeichen an die gegebene Position
 */
void CGLCanvas::DrawChar( int x, int y, unsigned char c)
{
    if ( c <= 32 )
        return;     // Nicht druckbar ( space usw. )

    // ToDo: Testen ob Zeichen ueberhaupt auf dem Bildschirm d.h. sichtbar

    int row = c >> 4;   // / 16
    int col = c & 15;   // letzten 4 Bits

    float fw = 1.0f / 16.0f;
    float fh = 1.0f / 16.0f;
    float frow = row * fh;
    float fcol = col * fw;

    glBegin(GL_QUADS);
        glTexCoord2f(fcol,      frow);      glVertex2i( x,      y      );   // links oben
        glTexCoord2f(fcol,      frow + fh); glVertex2i( x,      y + 16 );   // links unten
        glTexCoord2f(fcol + fw, frow + fh); glVertex2i( x + 16, y + 16 );   // rechts unten
        glTexCoord2f(fcol + fw, frow);      glVertex2i( x + 16, y      );   // rechts oben
    glEnd();
}

/*
 *  GetTextExtent( )
 *  Gibt die Breite und Hoehe des Textes in Pixeln zurueck
 */
wxPoint CGLCanvas::GetTextExtent( const char *szText )
{
    wxPoint pt(0, 0);
    if( m_pFont == NULL || szText == NULL )
        return pt;

    // Hoehe, zur Zeit immer fest
    pt.y  = 16;

    // Breite aufsummieren
    for(int i=0; szText[i]; i++)
    {
        pt.x += g_aGlyphWidths[((unsigned char)szText[i])];
    }

    return pt;
}

/*----------------------------------------------------------------------------/
    Textur Funktionen
-----------------------------------------------------------------------------*/

/*
 *  LoadTexture( )
 *  Laed ein .png Bild aus einer Datei und erzeugt davon eine OpenGL Texture
 */
CTexture* CGLCanvas::LoadTexture( string strTexture, bool bMipMap )
{
    // Pruefen, ob Texture schon geladen:
    TexMap::iterator tex = m_aTextures.find( strTexture );
    if( tex != m_aTextures.end() )
    {
        CTexture *pTex = tex->second;
        pTex->IncRefCount();
        return pTex;            // Breits geladen -> gleich zurueckgeben
    }

    // Bilddatei laden. Wenn dies nicht klappt, wird eine Standardtextur erstellt
    wxImage image;
    if( image.LoadFile( strTexture.c_str() ) == false )
    {
        logFile << "ERROR: Unable to load " << strTexture << ". Loading default texture." << endl;

        // Default Textur erzeugen
        image.Create( 8, 8 );

        // Schwarz/Rotes Muster erzeugen
        BYTE *pData = image.GetData();
        for( int i=0; i<8*8; i++ )
        {
            *pData++ = ((i&1) ^ ((i&8)==8)) ? 255 : 0;      // Ohne Worte.
            *pData++ = 0;
            *pData++ = 0;
        }
    }

    // OpenGL Texture erzeugen
    CTexture *pTexture = CreateTexture( &image, strTexture, bMipMap );
    if( pTexture == NULL )
    {
        logFile << "ERROR: Unable to create Texture '" << strTexture << "'." << endl;
        return NULL;
    }

    // Geladene Texturen zur map hinzufgen
    m_aTextures.insert( TexMap::value_type( strTexture, pTexture ) );

    return pTexture;
}

/*
 *  CreateTexture( )
 *
 */
CTexture* CGLCanvas::CreateTexture( wxImage *pImage, string strTexture, bool bMipMap )
{
    // Pruefen ob ein OpenGL Kontext vorhanden ist
    if (!GetContext())
    {
        cout << "***ERROR: GlCanvas::CreateTexture: Kein Kontext!" << endl;
        return false;
    }
    SetCurrent();

    // Sicherstellen das Breite/Hoehe der Textur eine Zweierpotenz ist
    int w = power_of_two( pImage->GetWidth() );
    int h = power_of_two( pImage->GetHeight() );
    int bpp = 3;

    // Pruefen ob das Bild transparente Bereiche hat
    bool bMask = pImage->HasMask();
    BYTE mr, mg, mb;
    if( bMask )
    {
        mr = pImage->GetMaskRed();      // Maske abfragen
        mg = pImage->GetMaskGreen();
        mb = pImage->GetMaskBlue();
        bpp = 4;
    }

    // Attribute der Textur abfragen
    int cols = pImage->GetWidth();
    int rows = pImage->GetHeight();
    BYTE *dest, *bmp = pImage->GetData();
    BYTE *rgba = new BYTE[w * h * bpp];
    memset( rgba, 0, w*h*bpp );             // ToDo: In Schleife unten einbauen!

    // Texture skalieren, so das die Breite und Hoehe ein Potenz von 2 ist,
    // sonst kann OpenGL die Textuer nicht laden!
    /*for( int row = 0; row < h; row++ )
    {
        dest = rgba  + row * w;                 // Anfang der Zeile berechnen

        if( row < rows)
        {
            for(int col = 0; col < w; col++)
                *dest++ = col<cols ? *bmp++ : 0;    // Zeile kopieren
        }
        else
        {
            for(int col = 0; col < w; col++)        // Leere Zeilen
                *dest++ = 0;
        }
    }*/

    // Schneller, jedoch werden die Raender nicht bearbeitet
    for( int row = 0; row < rows; row++ )
    {
        dest = rgba  + row * w * bpp;           // Anfang der Zeile berechnen
        for(int col = 0; col < cols; col++)     // Zeile kopieren
        {
            *dest++ = *bmp++;
            *dest++ = *bmp++;
            *dest++ = *bmp++;

            if( bMask )
            {
                if( dest[-3] == mr && dest[-2] == mg && dest[-1] == mb )
                    *dest++ = 0;
                else
                    *dest++ = 255;
            }
        }
    }

    // OpenGL Texture erzeugen
    GLuint nTextureID;
    glGenTextures(1, &nTextureID);

    // Neue Textur binden
    glBindTexture(GL_TEXTURE_2D, nTextureID);
    if(glGetError() != GL_NO_ERROR)
    {
        logFile << "***ERROR: CGLCanvas::CreateTexture: glBindTexture failed!" << endl;
        return NULL;
    }

    // Daten vom Bild auf die Textur kopieren
    if( bMipMap )   // Mit MipMaps
    {
        BuildMipmaps( w, h, GL_RGBA, 4, (BYTE*) rgba );
        if(glGetError() != GL_NO_ERROR)
        {
            logFile << "***ERROR: CGLCanvas::CreateTexture: BuildMipmaps failed!" << endl;
            return NULL;
        }

        // Vergroesserung/Verkleinerungs Attribute setzen
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST );
        if(glGetError() != GL_NO_ERROR)
            return NULL;
    }
    else    // Ohne MipMaps
    {
        glTexImage2D( GL_TEXTURE_2D, 0, 4, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (BYTE*)rgba );
        if(glGetError() != GL_NO_ERROR)
        {
            logFile << "***ERROR: CGLCanvas::CreateTexture: glTexImage2D failed!" << endl;
            return NULL;
        }

        // Vergroesserung/Verkleinerungs Attribute setzen
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
        if(glGetError() != GL_NO_ERROR)
            return NULL;
    }

    // Neue Textur erzeugen und Attribute setzen
    CTexture *pTexture = new CTexture( strTexture );
    pTexture->m_nWidth  = w;
    pTexture->m_nHeigth = h;
    pTexture->m_nOriginalWidth  = cols;
    pTexture->m_nOriginalHeigth = rows;
    pTexture->m_nRefCount = 1;
    pTexture->m_nTexureID = nTextureID;

    // Aufraeumen
    delete [] rgba;

    return pTexture;
}

/*
 *  BuildMipmaps( )
 *  Erzeugt eine Bildpyramide indem es die Breite und Hoehe des Bildes so lange halbiert, bis
 *  das Bild nur noch eine Groesse von 1x1 Pixel hat. Dadurch kann OpenGL schneller zeichnen
 *  wenn die Textur verkleinert werden muss, z.B. beim Rauszoomen
 */
void CGLCanvas::BuildMipmaps(int nWidth, int nHeigth, GLenum nFormat, int nBpp, BYTE *pData)
{
    if( nWidth < 1 || nHeigth < 1 )
        return;

    BYTE *d = pData;
    int   w = nWidth;
    int   h = nHeigth;

    int nLevel = 0;
    while( true )
    {
        // Textur zur Bildpyramide hinzufgen
        glTexImage2D( GL_TEXTURE_2D, nLevel, nBpp, w, h, 0, nFormat, GL_UNSIGNED_BYTE, d );

        if( w == 1 && h == 1)                       // Bei 1x1 Pixel ist schluss
            break;

        int   neww = (w<2) ? 1 : w/2;               // Neue H�e und Breite berechnen
        int   newh = (h<2) ? 1 : h/2;
        BYTE *newd = new BYTE[neww * newh * nBpp];  // Speicher reservieren

        ScaleForWDS( w, h, d, neww, newh, newd );   // Bild verkleinern

        if( d != pData )
            delete [] d;

        nLevel++;
        w = neww;
        h = newh;
        d = newd;
    }

    if( d != pData )
        delete [] d;
}

/*
 *  ScaleForWDS( )
 *  Verkleinert das gegebene Bild, wobei nur nichttransparente Pixel beruecksichtigt werden.
 *  Dadurch entstehen an den Raendern der Kacheln keine Artefakte ( wie schwarzer Rand ).
 *  Weiterhin wird das Bild geglaettet.
 */
void CGLCanvas::ScaleForWDS( int inw, int inh, BYTE *in, int outw, int outh, BYTE *out )
{
    BYTE *dest, *src;
    int sy = (inh == 1 ? 1 : 2);
    int sx = (inw == 1 ? 4 : 8);

    int r, g, b;
    int n;

    for( int y=0; y<outh; y++ )
    {
        dest = out + outw * y * 4;
        src  = in  + inw  * y * 4 * sy;
        for ( int x=0; x<outw ; x++ )
        {
            r = g = b = 0;
            n = 0;

            if( src[3] == 255 )
            {
                r += src[0]; g += src[1]; b += src[2]; n++;
            }

            if( inw > 1 && src[7] == 255  )
            {
                r += src[4]; g += src[5]; b += src[6]; n++;
            }

            if( inh > 1 && src[inw*4+3] == 255 )
            {
                r += src[inw*4]; g += src[inw*4+1]; b += src[inw*4+2]; n++;
            }

            if( inh > 1 && inw > 1 && src[inw*4+7] == 255)
            {
                r += src[inw*4+4]; g += src[inw*4+5]; b += src[inw*4+6]; n++;
            }

            if( n > 0 )
            {
                dest[0] = r / n; dest[1] = g / n; dest[2] = b / n; dest[3] = 255;   // Gewichtetes Mittel -> Glaettung
            }
            else
            {
                dest[3] = 0;    // Transparenter Pixel
            }

            dest += 4;
            src  += sx;
        }
    }
}

void CGLCanvas::DeleteTexture( CTexture *pTexture )
{
    if( !pTexture )
        return;

    pTexture->DecRefCount();
    if( pTexture->m_nRefCount == 0 )    // Textur wird nicht mehr benutzt
    {
        TexMap::iterator tex = m_aTextures.find( pTexture->GetName() );
        if( tex != m_aTextures.end() )
            m_aTextures.erase( tex );
        delete pTexture;
    }
}

/*
 *  Gibt die naechste 2er Potenz zurueck
 */
int CGLCanvas::power_of_two(int input)
{
    int value = 1;
    while ( value < input )
        value <<= 1;
    return value;
}

}
// kate: space-indent off; tab-width 4; replace-tabs off;

---