DGL • Thema anzeigen - AGLDrawable is deprecated

AGLDrawable is deprecated

Moderator: DGL-Team

Seite 1 von 1

[ 5 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

lala123

Betreff des Beitrags: AGLDrawable is deprecated

Verfasst: Di Sep 29, 2009 13:46

DGL Member

Registriert: Di Sep 29, 2009 13:28
Beiträge: 3

Hallo alle miteinander,
ich arbeite an einem Programm, das ich nicht selbst geschrieben habe, aber eben ein wenig umgestalten möchte. Dieses Programm benutzt wxWidgets und OpenGL. Es soll ein Fenster erscheinen, in dem ein Simulation stattfinden kann und Buttons gedrückt werden können. Wenn ich das Programm versuche über die Konsole zu kompilieren, erscheint die Fehlermeldung: 'AGLDrawable is deprecated' - ich arbeite an einem Mac-10.5 und habe dann in der agl-Header Datei nachgeschaut und erfahren, dass diese Funktion nicht mehr unterstützt wird. Also habe ich diese durch WindowRef ersetzt. Jetzt hat er keine Probleme mehr und kann kopilieren.
Das Problem nun ist aber, dass, wenn ich die GUI Datei ausführe die folgende Fehlermeldung kommt:

Code:

Last login: Tue Sep 29 14:02:25 on ttys001
/Users/praktikant/Desktop/CancerSim/GUI ; exit;
maggy:~ praktikant$ /Users/praktikant/Desktop/CancerSim/GUI ; exit;
Assertion failed: (0), function aglSetIntegerHIViewRef, file aglHIView.c, line 395.
Abort trap
logout
 
[Prozess beendet]
 

Ich habe keine Ahnung, woran es liegt. Sollte ich mich allgemein von AGL trennen und Quartz benutzen oder so? Davon hab ich aber auch keinen Schimmer, zu mal ich nicht glaube, dass ich das so einfach umwandeln kann. Woran liegt das?
Wenn noch was benötigt wird, bitte Bescheid sagen:

Ich bin für jede Hilfe dankbar! [/pascal]

Nach oben

Aya

Betreff des Beitrags:

Verfasst: Di Sep 29, 2009 16:05

DGL Member

Registriert: Di Dez 03, 2002 22:12
Beiträge: 2105
Wohnort: Vancouver, Canada
Programmiersprache: C++, Python

Hi,

so ganz ohne code kann ich dir da leider nicht helfen... AGLDrawable ist deprecated und wurde afaik in 10.6 sogar ganz rausgenommen (in 10.5 war es halt 'nur' deprecated).

Was verstehst du unter "habe es durch WindowRef ersetzt"?
Und wo bekommst du die WindowRef her? Liefert die wxWidget das?

Und generell.. erstellst du den context etc selbst, oder macht wxWidget das?

Ansonsten kann ich nur sagen, von AGL trennen mußt du dich nicht unbedingt.. es ist allerdings teil der Carbon API welche leider mittlerweile nichtmehr groß weiterentwickelt wird (z.B. kannst du via Carbon keine 64bit programme erstellen).

Es empfiehlt sich daher auf Cocoa umzusteigen (Objective-C, kann aber problemlos mit C++ code gemixt werden) und sogar den context via Cocoa zu erstellen (NSOpenGLContext).

Ich hatte anfangs auch alles via Carbon/AGL gemacht, nur leider stößt man da schnell an die grenzen des machbaren (nicht unbedingt bei AGL, sondern eher bei Carbon...)

Also, wenn du bei AGL bleiben willst zeig mal ein wenig mehr code, bzw erklär genauer was du wie wo warum ausgetauscht hast etc.

Aya~

Nach oben

lala123

Betreff des Beitrags:

Verfasst: Mi Sep 30, 2009 09:45

DGL Member

Registriert: Di Sep 29, 2009 13:28
Beiträge: 3

okay, ich zeig dir mal die Files, in denen agl verwendet wird:
glcanvas.cc

Code:

 
#include "wx/wxprec.h"
 
#if defined(__BORLANDC__)
    #pragma hdrstop
#endif
 
#if wxUSE_GLCANVAS
 
#include "wx/glcanvas.h"
 
#ifndef WX_PRECOMP
    #include "wx/frame.h"
    #include "wx/log.h"
    #include "wx/settings.h"
#endif
 
#include "wx/mac/uma.h"
 
// DLL options compatibility check:
#include "wx/build.h"
WX_CHECK_BUILD_OPTIONS("wxGL")
 
#include "wx/mac/private.h"
 
/*
* GLContext implementation
*/
 
wxGLContext::wxGLContext(
                         AGLPixelFormat fmt, wxGLCanvas *win,
                         const wxPalette& palette,
                         const wxGLContext *other        /* for sharing display lists */
                         )
{
    m_window = win;
#ifndef __LP64__
    m_drawable = (WindowRef) UMAGetWindowPort(MAC_WXHWND(win->MacGetTopLevelWindowRef()));
#endif
 
    m_glContext = aglCreateContext(fmt, other ? other->m_glContext : NULL);
    wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
 
    GLboolean b;
#ifndef __LP64__
    b = aglSetWindowRef(m_glContext, m_drawable);
    aglEnable(m_glContext , AGL_BUFFER_RECT ) ;
#else
    b = aglSetWindowRef(m_glContext, (WindowRef) win->GetHandle());
#endif
    wxCHECK_RET( b, wxT("Couldn't bind OpenGl context") );
    b = aglSetCurrentContext(m_glContext);
    wxCHECK_RET( b, wxT("Couldn't activate OpenGl context") );
}
 
wxGLContext::~wxGLContext()
{
    if (m_glContext)
    {
        aglSetCurrentContext(NULL);
        aglDestroyContext(m_glContext);
    }
}
 
void wxGLContext::SwapBuffers()
{
    if (m_glContext)
    {
        aglSwapBuffers(m_glContext);
    }
}
 
void wxGLContext::SetCurrent()
{
    if (m_glContext)
    {
        aglSetCurrentContext(m_glContext);
    }
}
 
void wxGLContext::Update()
{
    if (m_glContext)
    {
        aglUpdateContext(m_glContext);
    }
}
 
void wxGLContext::SetColour(const wxChar *colour)
{
    wxColour col = wxTheColourDatabase->Find(colour);
    if (col.Ok())
    {
        float r = (float)(col.Red()/256.0);
        float g = (float)(col.Green()/256.0);
        float b = (float)(col.Blue()/256.0);
        glColor3f( r, g, b);
    }
}
 
 
/*
* wxGLCanvas implementation
*/
 
IMPLEMENT_CLASS(wxGLCanvas, wxWindow)
 
BEGIN_EVENT_TABLE(wxGLCanvas, wxWindow)
    EVT_SIZE(wxGLCanvas::OnSize)
END_EVENT_TABLE()
 
wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
                       const wxPoint& pos, const wxSize& size, long style, const wxString& name,
                       int *attribList, const wxPalette& palette)
{
    Create(parent, NULL, id, pos, size, style, name, attribList, palette);
}
 
wxGLCanvas::wxGLCanvas( wxWindow *parent,
                       const wxGLContext *shared, wxWindowID id,
                       const wxPoint& pos, const wxSize& size, long style, const wxString& name,
                       int *attribList, const wxPalette& palette )
{
    Create(parent, shared, id, pos, size, style, name, attribList, palette);
}
 
wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID id,
                       const wxPoint& pos, const wxSize& size, long style, const wxString& name,
                       int *attribList, const wxPalette& palette )
{
    Create(parent, shared ? shared->GetContext() : NULL, id, pos, size, style, name, attribList, palette);
}
 
wxGLCanvas::~wxGLCanvas()
{
    if (m_glContext != NULL) {
        delete m_glContext;
        m_glContext = NULL;
    }
}
 
static AGLPixelFormat ChoosePixelFormat(const int *attribList)
{
    GLint data[512];
    GLint defaultAttribs[] = { AGL_RGBA,
        AGL_DOUBLEBUFFER,
        AGL_MINIMUM_POLICY,
        AGL_DEPTH_SIZE, 1,  // use largest available depth buffer
        AGL_RED_SIZE, 1,
        AGL_GREEN_SIZE, 1,
        AGL_BLUE_SIZE, 1,
        AGL_ALPHA_SIZE, 0,
        AGL_NONE };
    GLint *attribs;
    if (!attribList)
    {
        attribs = defaultAttribs;
    }
    else
    {
        int arg=0, p=0;
 
        data[p++] = AGL_MINIMUM_POLICY; // make _SIZE tags behave more like GLX
        while( (attribList[arg]!=0) && (p<512) )
        {
            switch( attribList[arg++] )
            {
            case WX_GL_RGBA: data[p++] = AGL_RGBA; break;
            case WX_GL_BUFFER_SIZE:
                data[p++]=AGL_BUFFER_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_LEVEL:
                data[p++]=AGL_LEVEL; data[p++]=attribList[arg++]; break;
            case WX_GL_DOUBLEBUFFER: data[p++] = AGL_DOUBLEBUFFER; break;
            case WX_GL_STEREO: data[p++] = AGL_STEREO; break;
            case WX_GL_AUX_BUFFERS:
                data[p++]=AGL_AUX_BUFFERS; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_RED:
                data[p++]=AGL_RED_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_GREEN:
                data[p++]=AGL_GREEN_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_BLUE:
                data[p++]=AGL_BLUE_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_ALPHA:
                data[p++]=AGL_ALPHA_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_DEPTH_SIZE:
                data[p++]=AGL_DEPTH_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_STENCIL_SIZE:
                data[p++]=AGL_STENCIL_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_ACCUM_RED:
                data[p++]=AGL_ACCUM_RED_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_ACCUM_GREEN:
                data[p++]=AGL_ACCUM_GREEN_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_ACCUM_BLUE:
                data[p++]=AGL_ACCUM_BLUE_SIZE; data[p++]=attribList[arg++]; break;
            case WX_GL_MIN_ACCUM_ALPHA:
                data[p++]=AGL_ACCUM_ALPHA_SIZE; data[p++]=attribList[arg++]; break;
            default:
                break;
            }
        }
        data[p] = 0;
 
        attribs = data;
    }
 
    return aglChoosePixelFormat(NULL, 0, attribs);
}
 
bool wxGLCanvas::Create(wxWindow *parent, const wxGLContext *shared, wxWindowID id,
                        const wxPoint& pos, const wxSize& size, long style, const wxString& name,
                        int *attribList, const wxPalette& palette)
{
    m_macCanvasIsShown = false ;
    m_glContext = 0 ;
    wxWindow::Create( parent, id, pos, size, style, name );
 
    AGLPixelFormat fmt = ChoosePixelFormat(attribList);
    wxCHECK_MSG( fmt, false, wxT("Couldn't create OpenGl pixel format") );
 
    m_glContext = new wxGLContext(fmt, this, palette, shared);
    m_macCanvasIsShown = true ;
    aglDestroyPixelFormat(fmt);
 
    return true;
}
 
void wxGLCanvas::SwapBuffers()
{
    if (m_glContext)
        m_glContext->SwapBuffers();
}
 
void wxGLCanvas::UpdateContext()
{
    if (m_glContext)
        m_glContext->Update();
}
 
void wxGLCanvas::SetViewport()
{
#ifndef __LP64__
    // viewport is initially set to entire port
    // adjust glViewport to just this window
    int x = 0 ;
    int y = 0 ;
 
    wxWindow* iter = this ;
    while( iter->GetParent() )
    {
        iter = iter->GetParent() ;
    }
 
    if ( iter && iter->IsTopLevel() )
    {
        MacClientToRootWindow( &x , &y ) ;
        int width, height;
        GetClientSize(& width, & height);
        Rect bounds ;
#if 0
        // TODO in case we adopt point vs pixel coordinates, this will make the conversion
        GetWindowPortBounds( MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds ) ;
        HIRect hiRect = CGRectMake( x, y, width, height ) ;
        HIRectConvert( &hiRect, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceScreenPixel, NULL) ;
        HIRect hiBounds = CGRectMake( 0, 0, bounds.right - bounds.left , bounds.bottom - bounds.top ) ;
        HIRectConvert( &hiBounds, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceScreenPixel, NULL) ;
        GLint parms[4] ;
        parms[0] = hiRect.origin.x ;
        parms[1] = hiBounds.size.height - (hiRect.origin.y + hiRect.size.height) ;
        parms[2] = hiRect.size.width ;
        parms[3] = hiRect.size.height ;
#else
        GetWindowPortBounds( MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds ) ;
        GLint parms[4] ;
        parms[0] = x ;
        parms[1] = bounds.bottom - bounds.top - ( y + height ) ;
        parms[2] = width ;
        parms[3] = height ;
#endif
        if ( !m_macCanvasIsShown )
            parms[0] += 20000 ;
        aglSetInteger( m_glContext->m_glContext , AGL_BUFFER_RECT , parms ) ;
        aglUpdateContext(m_glContext->m_glContext);
   }
#endif
}
 
void wxGLCanvas::OnSize(wxSizeEvent& event)
{
    MacUpdateView() ;
}
 
void wxGLCanvas::MacUpdateView()
{
    if (m_glContext)
    {
        SetViewport();
    }
}
 
void wxGLCanvas::MacSuperChangedPosition()
{
    MacUpdateView() ;
    wxWindow::MacSuperChangedPosition() ;
}
 
void wxGLCanvas::MacTopLevelWindowChangedPosition()
{
    MacUpdateView() ;
    wxWindow::MacTopLevelWindowChangedPosition() ;
}
 
void wxGLCanvas::SetCurrent()
{
    if (m_glContext)
    {
        m_glContext->SetCurrent();
    }
}
 
void wxGLCanvas::SetColour(const wxChar *colour)
{
    if (m_glContext)
        m_glContext->SetColour(colour);
}
 
bool wxGLCanvas::Show(bool show)
{
    if ( !wxWindow::Show( show ) )
        return false ;
    
    // call directly to avoid redraw glitches
    MacVisibilityChanged();
 
    return true ;
}
 
void wxGLCanvas::MacVisibilityChanged()
{
    if ( MacIsReallyShown() != m_macCanvasIsShown )
    {
        m_macCanvasIsShown = !m_macCanvasIsShown;
        MacUpdateView();
    }
    wxWindowMac::MacVisibilityChanged() ;
}
 
//---------------------------------------------------------------------------
// wxGLApp
//---------------------------------------------------------------------------
 
IMPLEMENT_CLASS(wxGLApp, wxApp)
 
bool wxGLApp::InitGLVisual(int *attribList)
{
    AGLPixelFormat fmt = ChoosePixelFormat(attribList);
    if (fmt != NULL) {
        aglDestroyPixelFormat(fmt);
        return true;
    } else
        return false;
}
 
wxGLApp::~wxGLApp(void)
{
}
 
#endif // wxUSE_GLCANVAS
 

und glcanvas.h

Code:

#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
 
#include "wx/defs.h"
 
#if wxUSE_GLCANVAS
 
#include "wx/palette.h"
#include "wx/scrolwin.h"
#include "wx/app.h"
 
#ifdef __DARWIN__
#  include <OpenGL/gl.h>
#  include <AGL/agl.h>
#else
#  include <gl.h>
#  include <agl.h>
#endif
 
class WXDLLEXPORT wxGLCanvas;     /* forward reference */
 
class WXDLLEXPORT wxGLContext: public wxObject
{
public:
   wxGLContext(AGLPixelFormat fmt, wxGLCanvas *win,
               const wxPalette& WXUNUSED(palette),
               const wxGLContext *other        /* for sharing display lists */
    );
   virtual ~wxGLContext();
 
   void SetCurrent();
   void Update();  // must be called after window drag/grows/zoom or clut change
   void SetColour(const wxChar *colour);
   void SwapBuffers();
 
 
   inline wxWindow* GetWindow() const { return m_window; }
   inline WindowRef aglGetWindowRef(AGLContext m_glContext) const { return m_drawable; }
 
public:
   AGLContext       m_glContext;
   WindowRef      m_drawable;
   wxWindow*        m_window;
};
 
class WXDLLEXPORT wxGLCanvas: public wxWindow
{
   DECLARE_CLASS(wxGLCanvas)
 public:
   wxGLCanvas(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize, long style = 0,
        const wxString& name = wxT("GLCanvas") , int *attribList = 0, const wxPalette& palette = wxNullPalette);
   wxGLCanvas( wxWindow *parent, const wxGLContext *shared,
        wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = wxT("GLCanvas"),
          int *attribList = (int*) NULL, const wxPalette& palette = wxNullPalette );
 
   wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID id = wxID_ANY,
        const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0,
        const wxString& name = wxT("GLCanvas"), int *attribList = 0, const wxPalette& palette = wxNullPalette );
 
   virtual ~wxGLCanvas();
 
   bool Create(wxWindow *parent, const wxGLContext *shared, wxWindowID id,
               const wxPoint& pos, const wxSize& size, long style, const wxString& name,
           int *attribList, const wxPalette& palette);
 
   void SetCurrent();
   void SetColour(const wxChar *colour);
   void SwapBuffers();
   void UpdateContext();
   void SetViewport();
   virtual bool Show(bool show = true) ;
 
   // Unlike some other platforms, this must get called if you override it.
   // It sets the viewport correctly and update the context.
   // You shouldn't call glViewport yourself either (use SetViewport if you must reset it.)
   void OnSize(wxSizeEvent& event);
 
   virtual void MacSuperChangedPosition() ;
   virtual void MacTopLevelWindowChangedPosition() ;
   virtual void         MacVisibilityChanged() ;
 
   void MacUpdateView() ;
 
   inline wxGLContext* GetContext() const { return m_glContext; }
 
protected:
    wxGLContext*   m_glContext;
    bool m_macCanvasIsShown ;
DECLARE_EVENT_TABLE()
};
 
#endif // wxUSE_GLCANVAS
#endif // _WX_GLCANVAS_H_
 

WindowRef ist in agl.h auch deklariert
Ausschnitt aus agl.h

Code:

/*
** Drawable Functions
*
*  Note:
*   aglSetDrawable / aglGetDrawable have been deprecated use aglGetWindowRef or aglSetHIViewRef
*/ 
extern GLboolean aglSetDrawable(AGLContext ctx, AGLDrawable draw) DEPRECATED_FOR_MAC_OS_X_VERSION_10_5_AND_LATER;
extern AGLDrawable aglGetDrawable(AGLContext ctx) DEPRECATED_FOR_MAC_OS_X_VERSION_10_5_AND_LATER;
 
/*
** WindowRef Functions
*/
extern GLboolean aglSetWindowRef(AGLContext ctx, WindowRef window) AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
extern WindowRef aglGetWindowRef(AGLContext ctx) AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
 
/*
** HIViewRef Functions
*/
extern GLboolean aglSetHIViewRef(AGLContext ctx, HIViewRef hiview) AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
extern HIViewRef aglGetHIViewRef(AGLContext ctx) AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
 
 

Hoffe, das hilft weiter!

Nach oben

lala123

Betreff des Beitrags:

Verfasst: Mi Sep 30, 2009 09:47

DGL Member

Registriert: Di Sep 29, 2009 13:28
Beiträge: 3

achso, wxWidgets erstellt den context

Nach oben

Aya

Betreff des Beitrags:

Verfasst: Mi Sep 30, 2009 15:41

DGL Member

Registriert: Di Dez 03, 2002 22:12
Beiträge: 2105
Wohnort: Vancouver, Canada
Programmiersprache: C++, Python

Hi,

umh.. ich finde in dem code keine AGLDrawable aufrufe (ausser in der agl.h halt..)

Allerdings, ich habe keine ahnung von wxWidgets... und ich fürchte, da wird mehr auf dich zukommen als einfach nur AGLDrawable durch WindowRef auszutauschen..

Schonmal geschaut ob es nicht ein update von wxWidgets zu dem thema gibt?

Allerdings, es ist ja nur deprecated.. sprich du kannst es im moment noch problemlos nutzen.

Aya~

Nach oben

Seite 1 von 1

[ 5 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.