SDL białe tło i nic więcej

[bies]

mam fedore a fedora ma to do siebie ze pakuje najnowsze wersje softu.. o ile na codzien moze to byc fajne to problem w tym ze Xorg 1.7.1 nie jest jeszcze przez ATI obcykany i nikomu nie udalo sie sterow tam odpalic. Choc moge sie mylic bo od dluzszego czasu sie temu nie przygladalem walczac z tym problemem. i nie mam r7xx tylko 4850 HD jesli chodzilo Ci o model karty, bodajze stery 9.12 sa dla kart 2xxx i nowszych.

R7xx to techniczna nazwa chipsetów kart HD4xxx (patrz [1], Twoja dokładnie karta to rv770), z resztą nieważne. Grunt, że na Fedorze będziesz pewnie musiał cofnąć Xorg i jądro do jakiejś starszej wersji aby sterowniki zadziałały. Fedora to kiepskie distro do binarnych sterowników (i bardzo dobre do otwartych -- ale to inna bajka). Binarne sterowniki dobrze działają na Ubuntu.

Vipa: co do sytemu, niekoniecznie. Na Linuksie masz OpenGL i tylko OpenGL i to jest priorytet. Na Windows priorytetem jest DX. I chociaż deweloperzy sterowników AMD zapewniają, że jądro OpenGL jest międzyplatformowe (trochę ponad rok temu przytaczał takie informacje serwis Phoronix) to podejrzewam, że na Linuksie jest lepiej (paradoksalnie) przetestowane.

Oczywiście błąd w kodzie jest jak najbardziej możliwy. Z resztą co ja mówię, nie bawiłem się jeszcze OpenGL 3.2.

[1] http://en.wikipedia.org/wiki/Radeon_R700

[Vipa]

Vipa: co do sytemu, niekoniecznie. Na Linuksie masz OpenGL i tylko OpenGL i to jest priorytet. Na Windows priorytetem jest DX. I chociaż deweloperzy sterowników AMD zapewniają, że jądro OpenGL jest międzyplatformowe (trochę ponad rok temu przytaczał takie informacje serwis Phoronix) to podejrzewam, że na Linuksie jest lepiej (paradoksalnie) przetestowane.

Oczywiście błąd w kodzie jest jak najbardziej możliwy. Z resztą co ja mówię, nie bawiłem się jeszcze OpenGL 3.2.

[1] http://en.wikipedia.org/wiki/Radeon_R700

Ja się bawię w OpenGL 2.0 od biedy więc nie mam porównania. Owszem, słyszałem jakieś głosy, że atan czy inne atoi (!!!) nie jest obsługiwane, ale to można zastąpić bardzo łatwo. Nigdy natomiast nie słyszałem o problemach z SDL.

Jeżeli ktoś ma takowe info bardzo proszę o kontakt.

[lord Snow]

Wiem ze to nie ladnie tak rzucac kodem ale zeby nie bylo watpliwosci, tak oto wyglada to co w tej chwili nie dziala:

Kod:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <GL3/gl3.h>
#include <SDL/SDL.h>
#include <math.h>
#include "utils.h"

PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
PFNGLGENBUFFERSPROC glGenBuffers;
PFNGLBINDBUFFERPROC glBindBuffer;
PFNGLBUFFERDATAPROC     glBufferData;
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
PFNGLCREATESHADERPROC glCreateShader;
PFNGLSHADERSOURCEPROC glShaderSource;
PFNGLCOMPILESHADERPROC glCompileShader;
PFNGLCREATEPROGRAMPROC glCreateProgram;
PFNGLATTACHSHADERPROC glAttachShader;
PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
PFNGLLINKPROGRAMPROC glLinkProgram;
PFNGLUSEPROGRAMPROC glUseProgram;
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
PFNGLDETACHSHADERPROC glDetachShader;
PFNGLDELETEPROGRAMPROC glDeleteProgram;
PFNGLDELETESHADERPROC glDeleteShader;
PFNGLDELETEBUFFERSPROC glDeleteBuffers;
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;

PFNGLCLEARCOLORPROC glClearColor;
PFNGLCLEARPROC glClear;
PFNGLGETSTRINGPROC glGetString;
PFNGLENABLEPROC glEnable;
PFNGLDEPTHFUNCPROC glDepthFunc;
PFNGLDRAWARRAYSPROC glDrawArrays;
PFNGLDRAWELEMENTSPROC glDrawElements;
PFNGLCLEARDEPTHPROC glClearDepth;

int main(int argc, char *argv[])
{
    SDL_WindowID  win;
    SDL_GLContext ctx;

    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        printf("Unable to initialize SDL");
        SDL_Quit();
        return 0;
    }

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);

    win = SDL_CreateWindow("help me!", 20, 40, 512, 512, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);

    if (!win)
    {
        printf("Unable to create window");
        SDL_Quit();
        return 0;
    }

    ctx = SDL_GL_CreateContext(win);

    SDL_GL_SetSwapInterval(1);

    glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glGenVertexArrays");
    glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) SDL_GL_GetProcAddress("glBindVertexArray");
    glGenBuffers = (PFNGLGENBUFFERSPROC) SDL_GL_GetProcAddress("glGenBuffers");
    glBindBuffer = (PFNGLBINDBUFFERPROC) SDL_GL_GetProcAddress("glBindBuffer");
    glBufferData = (PFNGLBUFFERDATAPROC) SDL_GL_GetProcAddress("glBufferData");
    glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) SDL_GL_GetProcAddress("glVertexAttribPointer");
    glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) SDL_GL_GetProcAddress("glEnableVertexAttribArray");
    glCreateShader = (PFNGLCREATESHADERPROC) SDL_GL_GetProcAddress("glCreateShader");
    glShaderSource = (PFNGLSHADERSOURCEPROC) SDL_GL_GetProcAddress("glShaderSource");
    glCompileShader = (PFNGLCOMPILESHADERPROC) SDL_GL_GetProcAddress("glCompileShader");
    glCreateProgram = (PFNGLCREATEPROGRAMPROC) SDL_GL_GetProcAddress("glCreateProgram");
    glAttachShader = (PFNGLATTACHSHADERPROC) SDL_GL_GetProcAddress("glAttachShader");
    glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) SDL_GL_GetProcAddress("glBindAttribLocation");
    glLinkProgram = (PFNGLLINKPROGRAMPROC) SDL_GL_GetProcAddress("glLinkProgram");
    glUseProgram = (PFNGLUSEPROGRAMPROC) SDL_GL_GetProcAddress("glUseProgram");
    glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) SDL_GL_GetProcAddress("glDisableVertexAttribArray");
    glDetachShader = (PFNGLDETACHSHADERPROC) SDL_GL_GetProcAddress("glDetachShader");
    glDeleteProgram = (PFNGLDELETEPROGRAMPROC) SDL_GL_GetProcAddress("glDeleteProgram");
    glDeleteShader = (PFNGLDELETESHADERPROC) SDL_GL_GetProcAddress("glDeleteShader");
    glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) SDL_GL_GetProcAddress("glDeleteBuffers");
    glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glDeleteVertexArrays");
    glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) SDL_GL_GetProcAddress("glUniformMatrix4fv");
    glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) SDL_GL_GetProcAddress("glGetUniformLocation");

    glDepthFunc = (PFNGLDEPTHFUNCPROC) SDL_GL_GetProcAddress("glDepthFunc");
    glDrawElements = (PFNGLDRAWELEMENTSPROC) SDL_GL_GetProcAddress("glDrawElements");
    glClearDepth = (PFNGLCLEARDEPTHPROC) SDL_GL_GetProcAddress("glClearDepth");
    glClearColor = (PFNGLCLEARCOLORPROC) SDL_GL_GetProcAddress("glClearColor");
    glClear = (PFNGLCLEARPROC) SDL_GL_GetProcAddress("glClear");
    glGetString = (PFNGLGETSTRINGPROC) SDL_GL_GetProcAddress("glGetString");
    glEnable = (PFNGLENABLEPROC) SDL_GL_GetProcAddress("glEnable");
    glDrawArrays = (PFNGLDRAWARRAYSPROC) SDL_GL_GetProcAddress("glDrawArrays");

    int i;
    GLuint vao, vbo[3];
    GLfloat projectionmatrix[16];
    GLfloat modelmatrix[16];
    const GLfloat identitymatrix[16] = IDENTITY_MATRIX4;

    const GLfloat tetrahedron[4][3] = {
    {  1.0,  1.0,  1.0  },
    { -1.0, -1.0,  1.0  },
    { -1.0,  1.0, -1.0  },
    {  1.0, -1.0, -1.0  } };

    const GLfloat colors[4][3] = {
    {  1.0,  0.0,  0.0  },
    {  0.0,  1.0,  0.0  },
    {  0.0,  0.0,  1.0  },
    {  1.0,  1.0,  1.0  } };

    const GLubyte tetraindicies[6] = { 0, 1, 2, 3, 0, 1 };

    GLchar *vertexsource, *fragmentsource, *geometrysource;
    GLuint vertexshader, fragmentshader, geometryshader, shaderprogram;

    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glGenBuffers(3, vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), tetrahedron, GL_STATIC_DRAW);
    glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), colors, GL_STATIC_DRAW);
    glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(1);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[2]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLubyte), tetraindicies, GL_STATIC_DRAW);

    vertexsource = filetobuf("tutorial4.vert");
    geometrysource = filetobuf("tutorial4.geom");
    fragmentsource = filetobuf("tutorial4.frag");

    vertexshader = glCreateShader(GL_VERTEX_SHADER);
    geometryshader = glCreateShader(GL_GEOMETRY_SHADER);
    fragmentshader = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(vertexshader, 1, (const GLchar**)&vertexsource, 0);
    glShaderSource(geometryshader, 1, (const GLchar**)&geometrysource, 0);
    glShaderSource(fragmentshader, 1, (const GLchar**)&fragmentsource, 0);

    glCompileShader(vertexshader);
    glCompileShader(geometryshader);
    glCompileShader(fragmentshader);

    shaderprogram = glCreateProgram();

    glAttachShader(shaderprogram, vertexshader);
    glAttachShader(shaderprogram, geometryshader);
    glAttachShader(shaderprogram, fragmentshader);

    glBindAttribLocation(shaderprogram, 0, "in_Position");
    glBindAttribLocation(shaderprogram, 1, "in_Color");

    glLinkProgram(shaderprogram);
    glUseProgram(shaderprogram);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);


    printf("GLVER: %s\n", glGetString(GL_VERSION));
    printf("GLSLV: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
    printf("VENDR: %s\n", glGetString(GL_VENDOR));
    printf("RENDR: %s\n", glGetString(GL_RENDERER));

    perspective(projectionmatrix, 45.0, 1.0, 0.1, 100.0);

    for (i=0; i < 360; i++)
    {
        memcpy(modelmatrix, identitymatrix, sizeof(GLfloat) * 16);
        rotate(modelmatrix, (GLfloat)i * -1.0, X_AXIS);
        rotate(modelmatrix, (GLfloat)i * 1.0, Y_AXIS);
        rotate(modelmatrix, (GLfloat)i * 0.5, Z_AXIS);
        translate(modelmatrix, 0, 0, -5.0);

        multiply4x4(modelmatrix, projectionmatrix);

        glUniformMatrix4fv(glGetUniformLocation(shaderprogram, "mvpmatrix"), 1, GL_FALSE, modelmatrix);

        glClearColor(1.0, 0.0, 0.0, 1.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


        glDrawElements(GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_BYTE, 0);

        SDL_GL_SwapWindow(win);
        SDL_Delay(33);
    }

    glUseProgram(0);
    glDisableVertexAttribArray(0);
    glDisableVertexAttribArray(1);
    glDetachShader(shaderprogram, vertexshader);
    glDetachShader(shaderprogram, geometryshader);
    glDetachShader(shaderprogram, fragmentshader);
    glDeleteProgram(shaderprogram);
    glDeleteShader(vertexshader);
    glDeleteShader(geometryshader);
    glDeleteShader(fragmentshader);
    glDeleteBuffers(3, vbo);
    glDeleteVertexArrays(1, &vao);
    free(vertexsource);
    free(geometrysource);
    free(fragmentsource);

    SDL_GL_DeleteContext(ctx);
    SDL_DestroyWindow(win);
    SDL_Quit();

    return 0;
}

A oto shadery:

Kod:

[b]vertex shader:[/b]

#version 150

precision highp float;

in vec3 in_Position;
in vec3 in_Color;

out vec3 geom_Color;

void main(void) {
    gl_Position = vec4(in_Position, 1.0);
    geom_Color = in_Color;
}


[b]geometry shader[/b]


#version 150

precision highp float;

uniform mat4 mvpmatrix;

// Declare what type of incoming primitive our geometry shader is receiving
layout(triangles) in;

// Declare what type of primitives we are creating and the maximum amount of vertices we will output per use of the geometry shader.
// We will be outputting 6 vertices per use of this shader, creating 2 triangles.
layout(triangle_strip, max_vertices = 6) out;

// Inputs to geometry shaders are always as arrays in the quantity of the incoming primitive
// In our case this value is 3, since triangles have 3 vertices
in vec3 geom_Color[3];
out vec3 ex_Color;

void main()
{
    // simple iterator
    int i;

    // Create our original primitive
    for (i=0; i < gl_in.length(); i++)
    {
        gl_Position = mvpmatrix * gl_in[i].gl_Position;
        ex_Color = geom_Color[i];
        EmitVertex();
    }
    EndPrimitive();

    // Create a new primitive with negative x,y,z values
    for (i=0; i < gl_in.length(); i++)
    {
        gl_Position = mvpmatrix * vec4(-gl_in[i].gl_Position.xyz, 1.0);
        ex_Color = geom_Color[i];
        EmitVertex();
    }
    EndPrimitive();
}


[b]fragment shader[/b]


#version 150
precision highp float;
in  vec3 ex_Color;
out vec4 gl_FragColor;

void main(void) {
    gl_FragColor = vec4(ex_Color,1.0);
}

Oczyscilem to wszystko z komentarzy i zamknalem wszystko w main zeby nie bylo watpliwosci co kiedy idzie. Moze cos zauwazycie ja juz wpatruje sie w to od kilku godzin.



A ha i takie male pytanko. Dlaczego SDL jest rozbity na kilka bibliotek? nie mowie o SDL_image czy SDL_audio whatever tylko o libSDL.a, libSDLmain.a oraz libSDL.dll.a. W sumie jeszcze nigdy nie interesowalem sie bibliotekami za bardzo wiec jakby ktos mogl to lopatologicznie wyjasnic bylbym wdzieczny. I jeszcze dlaczego musze je linkowac dokladnie w takiej kolejnosci: libSDLmain, libSDL.dll libSDL?


EDIT: przez pomylke dalem kod z ustawieniem kontekstu (SDL_GL_CONTEXT_MAJOR/MINOR_VERSION) na 2.1. To nie jest blad, z 3.2 tez nie dziala.. Juz poprawione

[cybek]

Jak dla mnie to wystarczy linkować libSDL.a czyli -lSDL jako parametr kompilacji.
Z tym że tuż przed mainem musisz dać: #undef main
biblioteka SDLmain jest, aby poprawniej (?) działało pod windowsem, takie dziwne coś, nie wiem, u mnie działa wg. w/w sposobu.
a to libSDL.dll.a to jest chyba po prostu odnośnik czy coś w ten deseń to faktycznej biblioteki. Zobacz sobie

[lord Snow]

Faktycznie wystarczy libSDL.a i #undef main ale potrzeba libSDL.dll.a zeby nie wywalalo bledow undefined reference do jakichs funkcji timeKillEvent i tym podobnych, wygladaja jak winapi czy cos w tym stylu.

[cybek]

Faktycznie wystarczy libSDL.a i #undef main ale potrzeba libSDL.dll.a zeby nie wywalalo bledow undefined reference do jakichs funkcji timeKillEvent i tym podobnych, wygladaja jak winapi czy cos w tym stylu.

Wszystkie funkcje SDL zaczynają się od nazwy SDL, także coś dziwnego tam mieszasz
Wpisujesz po prostu w parametr kompilatora -lSDL i po problemie.

[lord Snow]

No wlasnie sa to biblioteki windowsa (od gdi, win32 i systimer w kodzie sdl). W swoich projektach dodajecie jeszcze jakies biblioteki oprocz libSDL.a, opengl32 oraz mingw32 pod windowsem?

Cofnac Xorga pod fedora nie moge. Pisze mi ze tylko update jest downgrade nie mozliwy. Moze jakbym jakies repo dodal gdzie starsze wersje sa.

[cybek]

No wlasnie sa to biblioteki windowsa (od gdi, win32 i systimer w kodzie sdl).

Ale SDL jest linkowany dynamicznie, więc nie ma sensu linkować coś czego nie potrzebuje, biblioteka SDL skoro jest dynamiczna to powinna mieć w sobie wszystko zlinkowane co jest potrzebne.

[lord Snow]

O matko..........................

Wgralem dzis catalyst 10.1 beta i okazalo sie ze nadal problem jest.. alez oczywiscie ze jest skoro w shaderze uzywam gl_FragColor.....

Kod:

fragment shader

#version 150
precision highp float;
in  vec3 ex_Color;
out vec4 [b]gl_FragColor[/b];

void main(void) {
    [b]gl_FragColor[/b] = vec4(ex_Color,1.0);
}

Najprawdopodobniej programisci nVIDIA zostawili w driverze mozliwosc skorzystania z gl_FragColor jako domyslnego wyjscia fragment shadera lub tez pozwalaja na stosowanie tej nazwy jako wyjscia. ATI widocznie bardziej restrykcyjnie traktuje podejscie do OGL. Tutoriale z OpenGL wiki teraz dzialaja bez problemu. W Quick reference nie widze gl_FragColor wiec chyba poprawnie rozumuje. Rozumiem ze zastepstwem dla gl_FragColor jest gl_FrontColor? W kazdym razie dokonalem takiej zamiany:

Kod:

#version 150

precision highp float;

//out vec4 gl_FragColor;
out vec4 myfrag;

void main(void)
{
    // gl_FragColor = vec4(0.0, 1.0, 0.0 ,1.0);
    myfrag = vec4(0.0, 1.0, 0.0 ,1.0);
}

Pytanie dlaczego w tutorialu OpenGL ktos walnal takiego byka. Jak potwierdzicie moje podejrzenia napisze do autora artykulu.

[macbirdie]

Warning: Odgrzewam kotleta. Ale wydaje mi się w tym przypadku, że nie ma sensu zakładać nowego tematu.

Czy można rozumieć, że ten problem rozwiązałeś i geometria Ci się rysuje? Zabrałem się ostatnio za OpenGL 3.2 na moim Radku HD4670 i niestety nie renderuje się nic, prócz określonego przeze mnie koloru tła.

gl_FragColor jest owszem wycofany i jako atrybut wyjściowy z fragment shadera najlepiej jest podpiąć własny (poprzez glBindFragDataLocation), choć pierwszy napotkany w shaderze wyjściowy parametr zostanie jako taki potraktowany, z tego co rozumiem.

Mimo że tak robię, nie rysuje mi się absolutnie nic (prócz wspomnianego tła). Jeśli nie uruchomię w ogóle obróbki geometrii przez fragment shader, także nie pojawia się nic na mojej karcie, natomiast na NVIDII kolegi pojawia się czarny trójkąt, zatem prawdopodobnie tak jak powinno być. Pierwszego przypadku nie sprawdzałem na drugiej karcie, dziś jeszcze będę testował.

Co ciekawe nie działa zarówno mój prosty program, jak i różne przykłady pobrane z sieci i skompilowane, w tym np. te autorstwa Janusza Garnczarskiego.

I to wszystko na Catalyst 10.1. Czy AMD coś schrzanił? Dziś 10.2 wychodzi, być może coś poprawili, albo każdy popełnia jakiś błąd, który powoduje że na kartach ATI renderowanie nie działa, a NVIDIA jest na tyle pobłażliwa, że problemy z kodem są w zasadzie maskowane... :/

[Java]

ATI jest bardziej restrykcyjne jeśli chodzi o OpenGLa, z naciskiem na GLSL.

Możliwe, że w tutorialu jest byk, często tutoriale piszą ludzie, którzy sami nie do końca wiedzą co się dzieje

To czego nie rozumiem, to dlaczego się bawisz w loterię? Sprawdź logi z kompilacji shadera, przejedź GLSLdevilem, przejedź GLInterceptem, nie próbuj robić zmian na czuja...

[macbirdie]

Shadery kompilują się i shader program się linkuje bez błędów i ostrzeżeń (przy odpalaniu aplikacji w wersji debug błędy i ostrzeżenia kompilacji shaderów i linkowania programu są wyświetlane w output Visual Studio), ale nie miałem zielonego pojęcia o tych narzędziach, o których wspomniałeś - OpenGL to dla mnie dość świeża sprawa. Chciałem zdebugować za pomocą PerfStudio od AMD, ale po kilku godzinach walki i przeglądania dokumentacji wzdłuż i wszerz poległem i nie udało się nawet odpalić analizy, choć log serwera PerfStudio mówił że nie złapał momentu tworzenia kontekstu OpenGL - zarówno w moim programie, jak i kilku przykładowych innych autorów.

Dzięki, wieczorem zinterceptuję w takim razie co się dzieje.

[macbirdie]

 
glslDevil o ile jest ładny i zgrabny, nie bardzo lubi fragmentu w kodzie odpowiedzialnego za pobranie wskaźnika do funkcji wglCreateContextAttribsARB, gdyż tylko pod nim pobrany adres jest nieprawidłowy - odpalona z Visual Studio czy z konsoli aplikacja inicjuje kontekst w pełni prawidłowo. Nie przydał się zatem. glIntercept mnie nie zachęcił datami ostatniego uaktualnienia aplikacji, więc nie liczyłem że będzie przyjazny nowemu API.

Postawiłem nieco assertów (glGetError() == GL_NO_ERROR) przy niektórych głównych funkcjach i ukazał się rzeczywisty problem, w wyniku którego nic się nie renderowało. Po wielu niestety strzałach na ślepo, wielokrotnym sprawdzaniu czy sekwencja funkcji inicjalizacji kontekstu, ustawiania geometrii, buforów, jest rzeczywiście poprawna, okazało się, że "wystarczyło" usunąć z atrybutów inicjacji kontekstu 3.x pola WGL_CONTEXT_FLAGS_ARB i WGL_CONTEXT_PROFILE_MASK_ARB. Błąd (GL_INVALID_OPERATION) pojawiał się przy pierwszym wywołaniu dowolnej funkcji gl*, w moim przypadku glClearColor (a po jej usunięciu - przy glDrawArrays). Po zainicjowaniu bez tych parametrów wszystko nareszcie działa!

Czytałem że pierwsze sterowniki beta nVIDII obsługujące 3.2 także nie obsługiwały kontekstu forward compatible, później to prawdopodobnie poprawiono. Ciekawe czy ten sam problem teraz jeszcze występuje u ATI, nawet w dzisiejszych 10.2... Sprawdzałem także wystartować profil kompatybilny - też kiszka.

Pojawiały się u ludzi podobne problemy z inicjacją 3.2 na ATI, ale wątki szybko ucichały, więc nie wiem czy autorzy znajdowali rozwiązanie nie przyznając się, czy po prostu zapominali się pochwalić sukcesem. Cóż, nie liczę że moje "rozwiązanie" jest powodem do chwalenia się, bo może maskuję rzeczywisty problem inicjując kontekst tradycyjny, ale to mi na razie wystarcza, gdyż można działać dalej. A że głównie korzystam ze specyfikacji OpenGL 3.2 Core i GLSL, nie z tutoriali, to raczej nie użyję po drodze żadnych wycofanych funkcji czy technik.

Uff!