OpenGL Raum begrenzt?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • OpenGL Raum begrenzt?

    Hallo Entwickler,

    ist der "3D-Raum" in dem man zeichnen kann begrenzt?
    Wenn ich ein quadratisches Rechteck rotieren lasse werden die Ecken abgeschnitten.
    Wenn ich etwas mehr als 5.0 in den Raum verschiebe ist es nicht mehr zu sehen.
  • Bei mir kommt ein sehr merkwürdiger Fehler.
    Es ist so, als ob eine Ebene im vor allen anderen ist und irgendwie auch Ebenen hinzugefügt werden.
    Ausserdem werden die Farben verzerrt.

    Quellcode

    1. #import <Cocoa/Cocoa.h>
    2. #import <OpenGL/gl.h>
    3. #import <OpenGL/glu.h>
    4. #import <OpenGL/OpenGL.h>
    5. #import <QuartzCore/CVDisplayLink.h>
    6. @interface OpenGLView : NSOpenGLView
    7. {
    8. GLfloat fRotation;
    9. CVDisplayLinkRef displayLink;
    10. }
    11. @end
    Alles anzeigen


    Quellcode

    1. #import "OpenGLView.h"
    2. @interface OpenGLView()
    3. - (CVReturn)getFrameForTime:(const CVTimeStamp*)outputTime;
    4. @end
    5. @implementation OpenGLView
    6. - (void)prepareOpenGL
    7. {
    8. GLint swapInt = 1;
    9. [[self openGLContext] setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
    10. NSRect rect = [self bounds];
    11. glViewport(0, 0, (GLsizei)rect.size.width, (GLsizei)rect.size.height);
    12. glMatrixMode(GL_PROJECTION);
    13. glLoadIdentity();
    14. gluPerspective(45.0, rect.size.width / rect.size.height, 1.0, 5.0);
    15. glMatrixMode(GL_MODELVIEW);
    16. glLoadIdentity();
    17. CVDisplayLinkCreateWithActiveCGDisplays(&displayLink);
    18. CVDisplayLinkSetOutputCallback(displayLink, &MyDisplayLinkCallback, (__bridge void *) self);
    19. CGLContextObj cglContext = [[self openGLContext] CGLContextObj];
    20. CGLPixelFormatObj cglPixelFormat = [[self pixelFormat] CGLPixelFormatObj];
    21. CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(displayLink, cglContext, cglPixelFormat);
    22. CVDisplayLinkStart(displayLink);
    23. }
    24. - (void)renderScene
    25. {
    26. [[self openGLContext] makeCurrentContext];
    27. CGLLockContext((CGLContextObj)[[self openGLContext] CGLContextObj]);
    28. // Render - Start
    29. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    30. glLoadIdentity();
    31. glTranslatef(0.0, 0.0, -4.0);
    32. glRotatef(fRotation, 1.0, 0.0, 0.0);
    33. glBegin(GL_QUADS);
    34. {
    35. glColor3f(0.0f,1.0f,0.0f);
    36. glVertex3f( 1.0f, 1.0f,-1.0f);
    37. glVertex3f(-1.0f, 1.0f,-1.0f);
    38. glVertex3f(-1.0f, 1.0f, 1.0f);
    39. glVertex3f( 1.0f, 1.0f, 1.0f);
    40. glColor3f(1.0f,0.5f,0.0f);
    41. glVertex3f( 1.0f,-1.0f, 1.0f);
    42. glVertex3f(-1.0f,-1.0f, 1.0f);
    43. glVertex3f(-1.0f,-1.0f,-1.0f);
    44. glVertex3f( 1.0f,-1.0f,-1.0f);
    45. glColor3f(1.0f,0.0f,0.0f);
    46. glVertex3f( 1.0f, 1.0f, 1.0f);
    47. glVertex3f(-1.0f, 1.0f, 1.0f);
    48. glVertex3f(-1.0f,-1.0f, 1.0f);
    49. glVertex3f( 1.0f,-1.0f, 1.0f);
    50. glColor3f(1.0f,1.0f,0.0f);
    51. glVertex3f( 1.0f,-1.0f,-1.0f);
    52. glVertex3f(-1.0f,-1.0f,-1.0f);
    53. glVertex3f(-1.0f, 1.0f,-1.0f);
    54. glVertex3f( 1.0f, 1.0f,-1.0f);
    55. glColor3f(0.0f,0.0f,1.0f);
    56. glVertex3f(-1.0f, 1.0f, 1.0f);
    57. glVertex3f(-1.0f, 1.0f,-1.0f);
    58. glVertex3f(-1.0f,-1.0f,-1.0f);
    59. glVertex3f(-1.0f,-1.0f, 1.0f);
    60. glColor3f(1.0f,0.0f,1.0f);
    61. glVertex3f( 1.0f, 1.0f,-1.0f);
    62. glVertex3f( 1.0f, 1.0f, 1.0f);
    63. glVertex3f( 1.0f,-1.0f, 1.0f);
    64. glVertex3f( 1.0f,-1.0f,-1.0f);
    65. }
    66. glEnd();
    67. fRotation += 0.75;
    68. glFlush();
    69. // Render - Ende
    70. CGLFlushDrawable((CGLContextObj)[[self openGLContext] CGLContextObj]);
    71. CGLUnlockContext((CGLContextObj)[[self openGLContext] CGLContextObj]);
    72. }
    73. static CVReturn MyDisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeStamp* now, const CVTimeStamp* outputTime, CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* displayLinkContext)
    74. {
    75. return [(__bridge OpenGLView *)displayLinkContext getFrameForTime:outputTime];
    76. }
    77. - (CVReturn)getFrameForTime:(const CVTimeStamp*)outputTime
    78. {
    79. @autoreleasepool
    80. {
    81. [self renderScene];
    82. }
    83. return kCVReturnSuccess;
    84. }
    85. @end
    Alles anzeigen
  • Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Markus Müller ()

  • Warum sollte man kein glBegin() und so verwenden?
    Mir fällt es echt schwer ein gutes OpenGL 3.3 Tutorial zu finden und auch noch mit DisplayLink zu verbinden.
    Und in der SuperBible werden solche komischen GLTools verwendet, die man einbinden muss. Und GLUT möchte ich eigentlich auch nicht.

    Was ich überhaupt will:
    Ein verständliches Tutorial, bei dem kein extra einzubindender Code verwendet wird.
    Ich möchte eine einfache RenderLoop erstellen, bei der ich auch mit verschiedenenen Objekten rendern kann.

    Quellcode

    1. // RenderLoop
    2. for (Object *object in objectArray)
    3. {
    4. [object render];
    5. }
  • Der OpenGL fixed-function stack ist seit OpenGL 3 deprecated, weil moderne Grafikkarten (mehr oder weniger alles, was in den letzten 10Jahren gebaut wurde) gänzlich anders funktionieren.

    Letztlich können moderne GPUs nur aus ihrem VRAM arbeiten. Daher legt man Bufferobjekte an, diese enthalten dann die Geometriedaten (je mehr, desto besser), lädt Texturen etc in den GPU-VRAM und shader (Programme die direkt von der GPU massiv parallel ausgeführt werden) arbeiten dann auf diesen Daten. All das findet auf der Grafikkarte statt und kann dann extrem schnell verarbeitet werden, die CPU ist quasi nur noch für die Logistik verantwortlich.

    Das Problem mit glVertex, glBegin etc ist, dass jeder Vertex, Farbe, Dreieck usw. einzeln dem OpenGL-Stack übergeben werden, die GPU ihre Parallelität also nicht ausnutzen kann. Hinter den Kullissen setzt der OpenGL-Treiber das aber trotzdem zu bufferobjekten, shadern etc zusammen, aber das ist ungleich langsamer, als wenn Du die moderne OpenGL-API nutzt.

    Die verlinkten Tutorials erklären all das, ebenso die SuperBible. Das Thema ist komplex, wahrscheinlich wirst Du kein Tutorial finden, welches Deine Anforderungen erfüllt, da die meisten Anleitungen ein solides Verständnis der 3D-Programmierung sowie der jeweiligen Platform-API (Cocoa/CoreGraphics in diesem Fall) voraussetzen.

    Aber lass Dich nicht entmutigen und beiß Dich da durch.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Markus Müller ()

  • Also wenn Du direkt auf der OpenGL-Ebene arbeiten möchtest, dann führt an C++ eigentlich kaum ein Weg vorbei. Mehr oder weniger alle Beispiele und Tutorials im Netz verwenden C++ und genau für solche Hardware-nahe middleware ist C++ wie geschaffen. Wenn Du bei Objective-C bleiben möchtest, schaue Dir mal SceneKit ud GLKit an (beides unter NDA, brauchst einen Developerzugang).