Глубокое тестирование GL-приложений

[0] ALPHA_TEST (GL_ALWAYS, 0)
[0] AUTO_NORMAL
[1] BLEND (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
[0] CLIP_PLANE
[1] COLOR_MATERIAL (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
[0] CULL_FACE
[0] DEPTH_TEST
[1] DITHER
[0] FOG
[0] LIGHT
[0] LIGHTING
[0] LINE_SMOOTH
[0] LINE_STIPPLE
[0] LOGIC_OP
[0] MAP1_COLOR_4
[0] MAP1_INDEX
[0] MAP1_NORMAL
[0] NORMALIZE
[0] POINT_SMOOTH
[0] POLYGON_SMOOTH
[0] POLYGON_STIPPLE
[0] SCISSOR_TEST
[0] STENCIL_TEST
[0] TEXTURE_1D
[1] TEXTURE_2D (MIN: GL_LINEAR, MAG: GL_LINEAR, WRAP_S: GL_REPEAT, WRAP_T: GL_REPEAT, ENV_MODE: GL_MODULATE)
[0] TEXTURE_GEN_Q
[0] TEXTURE_GEN_R
[0] TEXTURE_GEN_S
[0] TEXTURE_GEN_T

SHADE_MODEL: GL_SMOOTH

FOG_HINT: GL_DONT_CARE
LINE_SMOOTH_HINT: GL_DONT_CARE
PERSPECTIVE_CORRECTION_HINT: GL_NICEST
POINT_SMOOTH_HINT: GL_DONT_CARE
POLYGON_SMOOTH_HINT: GL_DONT_CARE

type
  TWindowSettings = record
    dwStyle, dwExStyle : dword;
    X, Y : integer;
    WindowWidth, WindowHeight: integer;
  end;

function GetWindowSettings(FullScreen: boolean): TWindowSettings;
begin
  with Result do
  begin
    WindowWidth  := RenderWindowInfo.WindowWidth; // 800
    WindowHeight := RenderWindowInfo.WindowHeight; // 600

    if (FullScreen) then
    begin
        // bsNone
       dwStyle   := WS_POPUP or WS_CLIPCHILDREN or WS_CLIPSIBLINGS or WS_SYSMENU;
       dwExStyle := WS_EX_APPWINDOW;// or WS_EX_TOPMOST;

       X := 0;
       Y := 0;
    end else
    begin
        // bsSizable
       dwStyle   := WS_OVERLAPPED{WINDOW} or WS_SYSMENU or WS_CAPTION or WS_MAXIMIZEBOX or
                    WS_MINIMIZEBOX or WS_CLIPCHILDREN or WS_CLIPSIBLINGS;
       dwExStyle := WS_EX_APPWINDOW or WS_EX_WINDOWEDGE;

       Inc(WindowWidth, GetSystemMetrics(SM_CXDLGFRAME)*2);
       Inc(WindowHeight, GetSystemMetrics(SM_CYCAPTION)+GetSystemMetrics(SM_CYDLGFRAME)*2);

       X := (DefScreenMode.Width-WindowWidth) div 2;
       Y := (DefScreenMode.Height-WindowHeight) div 2;
    end;
  end;
end;

function CreateCrystalWindow(const GameID: string = '') : HWND;
var
  wndClass: TWndClass;
  _hInstance: integer;
begin
  _hInstance := hInstance;
  AppClassName := GetGameClassName(GameID);
  ZeroMemory(@wndClass, SizeOf(wndClass));

  with wndClass do
  begin
    style         := CS_HREDRAW or CS_VREDRAW or CS_OWNDC;
    lpfnWndProc   := @WindowProc;
    hInstance     := _hInstance;
    hIcon         := LoadIcon(_hInstance, 'MAINICON');
    lpszClassName := pchar(AppClassName);
  end;

  if (Windows.RegisterClass(wndClass) = 0) then
    TExcept.Assert('Failed to register window class "%s" !', [AppClassName]);

  with GetWindowSettings(EngineInstance.FullScreen{false}) do
  Result := CreateWindowEx(dwExStyle,pchar(AppClassName),'Loading...',dwStyle,
                           X, Y, WindowWidth, WindowHeight, 0, 0, hInstance, nil);

  if Result = 0 then
    TExcept.Assert('Unable to create window!');

  MinimizeWindow(Result); // SendMessage(Window, WM_SYSCOMMAND, SC_MINIMIZE, 0)
end;

procedure InitializeGL();
var
  pfd : TPIXELFORMATDESCRIPTOR;
  PixelFormat : integer;
begin
  h_DC := GetDC(EngineInstance.WindowHandle);
  if (h_DC = 0) then
    TExcept.Assert('Unable to get a device context!');

  ZeroMemory(@pfd, sizeof(pfd));
  with pfd do
  begin
    nSize           := sizeof(pfd);
    nVersion        := 1;
    dwFlags         := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or PFD_DOUBLEBUFFER;
    iPixelType      := PFD_TYPE_RGBA;
    cColorBits      := 32;
    cDepthBits      := 16;
    iLayerType      := PFD_MAIN_PLANE;
  end;

  PixelFormat := ChoosePixelFormat(h_DC, @pfd);
  if (PixelFormat = 0) then
    TExcept.Assert('Unable to find a suitable pixel format!');

  if (not SetPixelFormat(h_DC, PixelFormat, @pfd)) then
    TExcept.Assert('Unable to set the pixel format!');

  h_RC := wglCreateContext(h_DC);
  if (h_RC = 0) then
    TExcept.Assert('Unable to create an OpenGL rendering context!');

  if (not wglMakeCurrent(h_DC, h_RC)) then
    TExcept.Assert('Unable to activate OpenGL rendering context!');

//  BAD_DRIVER := (Pos('GDI', glGetString(GL_RENDERER)) <> 0) or (Pos('MICROSOFT', UpperCase(glGetString(GL_VENDOR))) <> 0);  

  EXTENSIONS := glGetString(GL_EXTENSIONS);

  @wglSwapIntervalEXT := wglGetProcAddress('wglSwapIntervalEXT');
  @wglGetSwapIntervalEXT := wglGetProcAddress('wglGetSwapIntervalEXT');
  SetVSync(EngineInstance.VSync);

  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_SMOOTH);
  glDisable(GL_DEPTH_TEST);
  glDepthFunc(GL_LEQUAL);
  glDisable(GL_ALPHA_TEST);
  glClearDepth(1.0);
  glEnable(GL_BLEND);
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  glEnable(GL_TEXTURE_2D);
  glDisable(GL_NORMALIZE);
  glEnable(GL_COLOR_MATERIAL);

  // VBO
  UseVBO := isExtensionSupported('GL_ARB_vertex_buffer_object');
  if (UseVBO) then
  begin
    // инициализация VBO-функций
    glBindBufferARB := wglGetProcAddress('glBindBufferARB');
    glDeleteBuffersARB := wglGetProcAddress('glDeleteBuffersARB');
    glGenBuffersARB := wglGetProcAddress('glGenBuffersARB');
    glBufferDataARB := wglGetProcAddress('glBufferDataARB');
    glMapBufferARB := wglGetProcAddress('glMapBufferARB');
    glUnmapBufferARB := wglGetProcAddress('glUnmapBufferARB');
    glEnableClientState := wglGetProcAddress('glEnableClientState');
    glDisableClientState := wglGetProcAddress('glDisableClientState');
    glVertexPointer := wglGetProcAddress('glVertexPointer');
    glColorPointer := wglGetProcAddress('glColorPointer');
    glTexCoordPointer := wglGetProcAddress('glTexCoordPointer');
    glDrawArrays := wglGetProcAddress('glDrawArrays');

    // создание буферов
    glGenBuffersARB(2, @VertexBuffers[false]);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, VertexBuffers[false]);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, MAX_QUADS_COUNT*sizeof(TQuad), nil, GL_STREAM_DRAW_ARB);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, VertexBuffers[true]);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, MAX_QUADS_COUNT*sizeof(TQuad), nil, GL_STREAM_DRAW_ARB);
  end else
  begin
    GetMem(VertexBuffer, MAX_QUADS_COUNT*sizeof(TQuad));
  end;

  // TestSupports
  pboolean(@NonbinaryTextureSupports)^ := isExtensionSupported('ARB_texture_non_power_of_two');
  pboolean(@CompressedTextureSupports)^ := isExtensionSupported('GL_ARB_texture_compression');
end;

procedure CreateTexture();
begin
    glGenTextures(1, @Texture);
    glBindTexture(GL_TEXTURE_2D, Texture);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameterf(GL_TEXTURE_2D, $8191{GENERATE_MIPMAP_SGIS}, 0);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 128, 128, 0, GL_BGRA, GL_UNSIGNED_BYTE, TextureData);
end;