mieki256's diary

• sysdm.cpl を実行して「システムのプロパティ」を開いて、詳細設定 → 起動と回復 → 自動的に再起動する、のチェックを外す。
• あるいは、管理者権限でコマンドプロンプト(cmd.exe)を開いて、「wmic recoveros set AutoReboot = false」と打つ。

1. AdvancedView に切替。
2. 左下の、Settings をクリック。
3. 「User Experience Program」が「Opt In」になっているので、クリックして「Opt Out」に変更。

#include <windows.h>

#define SCRW 512
#define SCRH 512

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
  HDC hdc, hBmpDC;
  PAINTSTRUCT ps;
  
  static HBITMAP hBitmap, hBitmap_mask, hBitmap_bg;
  static BITMAP bp;
  static int imgw, imgh;
  static int bgw, bgh;
  static int x, y;

  switch (msg)
    {
    case WM_CREATE:
      // load bitmaps
      hBitmap = LoadBitmap(((LPCREATESTRUCT)lp)->hInstance, TEXT("BALL_IMG"));
      hBitmap_mask = LoadBitmap(((LPCREATESTRUCT)lp)->hInstance, TEXT("BALL_MSK"));
      hBitmap_bg = LoadBitmap(((LPCREATESTRUCT)lp)->hInstance, TEXT("BG_IMG"));

      // get source image information
      GetObject(hBitmap, sizeof(BITMAP), &bp);
      imgw = bp.bmWidth;
      imgh = bp.bmHeight;

      // get bg image information
      GetObject(hBitmap_bg, sizeof(BITMAP), &bp);
      bgw = bp.bmWidth;
      bgh = bp.bmHeight;

      return 0;

    case WM_PAINT:
      x = 32;
      y = 32;

      hdc = BeginPaint(hwnd, &ps);

      // draw bg image
      hBmpDC = CreateCompatibleDC(hdc);
      SelectObject(hBmpDC, hBitmap_bg);
      BitBlt(hdc, 0, 0, bgw, bgh, hBmpDC, 0, 0, SRCCOPY);
      DeleteDC(hBmpDC);

      // draw mask
      hBmpDC = CreateCompatibleDC(hdc);
      SelectObject(hBmpDC, hBitmap_mask);
      BitBlt(hdc, x, y, imgw, imgh, hBmpDC, 0, 0, SRCAND);
      DeleteDC(hBmpDC);

      // draw source image
      hBmpDC = CreateCompatibleDC(hdc);
      SelectObject(hBmpDC, hBitmap);
      BitBlt(hdc, x, y, imgw, imgh, hBmpDC, 0, 0, SRCPAINT);
      DeleteDC(hBmpDC);

      EndPaint(hwnd, &ps);
      return 0;

    case WM_DESTROY:
      DeleteObject(hBitmap);
      DeleteObject(hBitmap_mask);
      DeleteObject(hBitmap_bg);
      PostQuitMessage(0);
      return 0;
    }

  return DefWindowProc(hwnd, msg, wp, lp);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR lpCmdLine, int nCmdShow)
{
  HWND hwnd;
  MSG msg;
  WNDCLASS winc;

  winc.style            = CS_HREDRAW | CS_VREDRAW;
  winc.lpfnWndProc      = WndProc;
  winc.cbClsExtra       = winc.cbWndExtra   = 0;
  winc.hInstance        = hInstance;
  winc.hIcon            = LoadIcon(NULL, IDI_APPLICATION);
  winc.hCursor          = LoadCursor(NULL, IDC_ARROW);
  winc.hbrBackground    = (HBRUSH)GetStockObject(WHITE_BRUSH);
  winc.lpszMenuName     = NULL;
  winc.lpszClassName    = TEXT("DrawBitmapSample");

  if (!RegisterClass(&winc)) return -1;

  hwnd = CreateWindow(
    TEXT("DrawBitmapSample"), TEXT("Draw Bitmap Sample"),
    WS_OVERLAPPEDWINDOW | WS_VISIBLE,
    CW_USEDEFAULT, CW_USEDEFAULT,
    SCRW, SCRH,
    NULL, NULL,
    hInstance, NULL
    );

  if (hwnd == NULL) return -1;

  while (GetMessage(&msg, NULL, 0, 0))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

  return msg.wParam;
}

BALL_IMG BITMAP "test.bmp"
BALL_MSK BITMAP "test_mask.bmp"
BG_IMG BITMAP "bg.bmp"

• bg.bmp。背景にする画像。
• test.bmp。元ソース画像。抜け部分にしたいところは黒(#000000)にしておく。
• test_mask.bmp。マスク画像。不透明部分は黒(#000000)、透明部分は白(#ffffff)にしておく。アルファチャンネルを白黒反転させた状態とも言える。

01_draw_bitmap.exe: 01_draw_bitmap.o bmp_res.o
        gcc 01_draw_bitmap.o bmp_res.o -o 01_draw_bitmap.exe -mwindows

01_draw_bitmap.o: 01_draw_bitmap.c
        gcc -c 01_draw_bitmap.c

bmp_res.o: bmp_res.rc test.bmp test_mask.bmp bg.bmp
        windres bmp_res.rc bmp_res.o

.PHONY: clean
clean:
        rm -f *.exe
        rm -f *.o

• マスク画像を AND (SRCAND) で重ねることで、マスク画像の黒い部分は黒く、白い部分は描画先の元の色が残る状態になる。
• 本来描きたかったソース画像を OR (SRCPAINT) で重ねることで、ぼっかり黒く抜けた部分にソース画像がハメ込まれるような状態になる。

#define WINVER          0x0501      // 0x0501 = WindowsXP
#define _WIN32_WINNT    0x0501

#include <windows.h>
#include <gdiplus.h>
using namespace Gdiplus;

#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdiplus.lib")

#define SCRW 512
#define SCRH 512

#define TM_COUNT1 1
#define FPS    60

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  HDC hdc;
  PAINTSTRUCT ps;
  static Image *img;
  static Image *bg;
  static Graphics *g;
  RECT rect;

  static float x, y, dx, dy;
  static int wdw_w, wdw_h;

  switch (uMsg)
    {
      case WM_CREATE:
        // get window size
        GetClientRect(hWnd, &rect);
        wdw_w = rect.right - rect.left;
        wdw_h = rect.bottom - rect.top;

        img = new Image(L"test.png");
        bg = new Image(L"bg.png");

        // int work
        x = (float)(wdw_w / 2);
        y = (float)(wdw_h / 2);
        dx = (float) wdw_w / (float)FPS;
        dy = dx * 0.7;

        SetTimer(hWnd, TM_COUNT1, (int)(1000 / FPS), NULL);
        break;

      case WM_TIMER:
        // main loop
        x += dx;
        y += dy;

        if (x <= 0 || x + img->GetWidth() >= wdw_w) dx *= -1;

        if (y <= 0 || y + img->GetHeight() >= wdw_h) dy *= -1;

        InvalidateRect(hWnd, NULL, TRUE);
        // InvalidateRect(hWnd, NULL, FALSE);
        break;

      case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        g = new Graphics(hdc);

        g->DrawImage(bg, 0, 0, bg->GetWidth(), bg->GetHeight());
        g->DrawImage(img, (int)x, (int)y, img->GetWidth(), img->GetHeight());

        delete (g);
        EndPaint(hWnd, &ps);
        break;

      case WM_DESTROY:
        delete (img);
        delete (bg);

        PostQuitMessage(0);
        break;

      default:
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

  return 0;
}

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
  MSG msg;
  GdiplusStartupInput gpSI;
  ULONG_PTR lpToken;

  /* GDI+初期化 */
  GdiplusStartup(&lpToken, &gpSI, NULL);

  HCURSOR hCursor = LoadCursor(NULL, IDC_ARROW);
  HBRUSH hBrush = (HBRUSH)(COLOR_WINDOW + 1);
  WNDCLASS wcl = { 0, WndProc, 0, 0, hInst, NULL, hCursor, hBrush, NULL, "mh" };
  DWORD style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

  if (!RegisterClass(&wcl) ||
      !CreateWindowEx(0, "mh", "gdiplus test",
                      style,
                      CW_USEDEFAULT, CW_USEDEFAULT,
                      SCRW, SCRH,
                      NULL, NULL, hInst, NULL))
    return FALSE;

  while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

  /* GDI+終了 */
  GdiplusShutdown(lpToken);

  return msg.wParam;
}

g++ 01_gdiplus01.cpp -o 01_gdiplus01.exe -mwindows -static -lstdc++ -lgcc -lgdiplus -lgdi32

• GDI+ を使うので、-lgdiplus -lgdi32 をつけないといかんらしい。

#include "resource.h"

IDI_BALL    RCDATA     "test.png"
IDI_BG      RCDATA     "bg.png"

#ifndef RESOURCE_H_
#define RESOURCE_H_

#define IDI_BALL    101
#define IDI_BG      102

#endif

#define WINVER          0x0501      // 0x0501 = WindowsXP
#define _WIN32_WINNT    0x0501

#include <windows.h>
#include <gdiplus.h>
#include "resource.h"

using namespace Gdiplus;

#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdiplus.lib")

#define SCRW 512
#define SCRH 512

#define TM_COUNT1 1
#define FPS  60

HINSTANCE hInst;

// Load image from resource
Bitmap *LoadImageFromResource(
  HINSTANCE hinst,  // handle instance
  LPCTSTR pName,  // resource ID
  LPCTSTR pType   // resource type
  )
{
  // Search resource
  HRSRC hRes = FindResource(hinst, pName, pType);

  if (hRes == NULL)
    {
      MessageBox(NULL, "Not found resource", "Error", MB_OK);
      return NULL;
    }

  // get resource size
  DWORD Size = SizeofResource(hinst, hRes);

  if (Size == 0)
    {
      MessageBox(NULL, "Resource size = 0", "Error", MB_OK);
      return NULL;
    }


  HGLOBAL hData = LoadResource(hinst, hRes);

  if (hData == NULL)
    {
      MessageBox(NULL, "Failure load resource", "Error", MB_OK);
      return NULL;
    }

  const void *pData = LockResource(hData);

  if (pData == NULL)
    {
      MessageBox(NULL, "Failure lock resource", "Error", MB_OK);
      return NULL;
    }

  // Copy resource data
  HGLOBAL hBuffer = GlobalAlloc(GMEM_MOVEABLE, Size);

  if (hBuffer == NULL)
    {
      MessageBox(NULL, "Failure alloc", "Error", MB_OK);
      return NULL;
    }

  void *pBuffer = GlobalLock(hBuffer);

  if (pBuffer == NULL)
    {
      MessageBox(NULL, "Failure lock", "Error", MB_OK);
      GlobalFree(hBuffer);
      return NULL;
    }

  CopyMemory(pBuffer, pData, Size);
  GlobalUnlock(hBuffer);

  // read image
  IStream *pStream;

  if (CreateStreamOnHGlobal(hBuffer, TRUE, &pStream) != S_OK)
    {
      MessageBox(NULL, "Failure create stream", "Error", MB_OK);
      GlobalFree(hBuffer);
      return NULL;
    }

  Bitmap *pBitmap = Bitmap::FromStream(pStream);
  pStream->Release();

  return pBitmap;
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  HDC hdc;
  PAINTSTRUCT ps;
  static Gdiplus::Bitmap* img;
  static Gdiplus::Bitmap* bg;

  static Graphics *g;
  RECT rect;

  static float x, y, dx, dy;
  static int wdw_w, wdw_h;

  switch (uMsg)
    {
    case WM_CREATE:
      // get window size
      GetClientRect(hWnd, &rect);
      wdw_w = rect.right - rect.left;
      wdw_h = rect.bottom - rect.top;

      img = LoadImageFromResource(hInst, MAKEINTRESOURCE(IDI_BALL), RT_RCDATA);
      bg = LoadImageFromResource(hInst, MAKEINTRESOURCE(IDI_BG), RT_RCDATA);

      // not work
      // img = LoadImageFromResource(hInst, TEXT("IDI_BALL"), TEXT("RCDATA"));
      // bg = LoadImageFromResource(hInst, TEXT("IDI_BG"), TEXT("RCDATA"));

      if (img != NULL && bg != NULL)
        {
          // init work
          x = (float)(wdw_w / 2);
          y = (float)(wdw_h / 2);
          dx = (float) wdw_w / (float)FPS;
          dy = dx * 0.5;

          // Set timer
          SetTimer(hWnd, TM_COUNT1, (int)(1000 / FPS), NULL);
        }

      break;

    case WM_TIMER:
      // main loop
      x += dx;
      y += dy;

      if (x <= 0 || x + img->GetWidth() >= wdw_w) dx *= -1;

      if (y <= 0 || y + img->GetHeight() >= wdw_h) dy *= -1;

      InvalidateRect(hWnd, NULL, TRUE);
      // InvalidateRect(hWnd, NULL, FALSE);
      break;

    case WM_PAINT:
      hdc = BeginPaint(hWnd, &ps);
      g = new Graphics(hdc);

      if (bg != NULL)
        g->DrawImage(bg, 0, 0, bg->GetWidth(), bg->GetHeight());

      if (img != NULL)
        g->DrawImage(img, (int)x, (int)y, img->GetWidth(), img->GetHeight());

      delete (g);
      EndPaint(hWnd, &ps);
      break;

    case WM_DESTROY:
      delete (img);
      delete (bg);

      PostQuitMessage(0);
      break;

    default:
      return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

  return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
  MSG msg;
  GdiplusStartupInput gpSI;
  ULONG_PTR lpToken;

  hInst = hInstance;

  /* GDI+初期化 */
  GdiplusStartup(&lpToken, &gpSI, NULL);

  HCURSOR hCursor = LoadCursor(NULL, IDC_ARROW);
  HBRUSH hBrush = (HBRUSH)(COLOR_WINDOW + 1);
  WNDCLASS wcl = { 0, WndProc, 0, 0, hInst, NULL, hCursor, hBrush, NULL, "mh" };
  DWORD style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

  if (!RegisterClass(&wcl) ||
      !CreateWindowEx(0, "mh", "gdiplus test",
                      style,
                      CW_USEDEFAULT, CW_USEDEFAULT,
                      SCRW, SCRH,
                      NULL, NULL, hInst, NULL))
    return FALSE;

  while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

  /* GDI+終了 */
  GdiplusShutdown(lpToken);

  return msg.wParam;
}

windres res.rc res.o
g++ -c 02_gdiplus_res.cpp
g++ 02_gdiplus_res.o res.o -o 02_gdiplus_res.exe -mwindows -static -lstdc++ -lgcc -lgdiplus -lgdi32 -lole32

• 上から順に、「リソースをコンパイルして .o を生成」「C++ソースをコンパイルして .o を生成」「.o群をリンクして.exe を生成」を行っている。
• CreateStreamOnHGlobal() がリンク時に見つからなかったけど、ole32 が必要になるらしい。リンクの指定として、-lole32 を追加した。

• ウインドウと同サイズの、空のbitmapを用意しておく。
• 一旦、そのbitmapにアレコレを描画。
• そのbitmapをウインドウ内に描画する。

#define WINVER          0x0501      // 0x0501 = WindowsXP
#define _WIN32_WINNT    0x0501

#include <windows.h>
#include <gdiplus.h>
#include "resource.h"

using namespace Gdiplus;

#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdiplus.lib")

#define SCRW 512
#define SCRH 512

#define TM_COUNT1 1
#define FPS  60

HINSTANCE hInst;

// Load image from resource
Bitmap *LoadImageFromResource(
  HINSTANCE hinst,  // handle instance
  LPCTSTR pName,  // resource ID
  LPCTSTR pType   // resource type
  )
{
  // Search resource
  HRSRC hRes = FindResource(hinst, pName, pType);

  if (hRes == NULL)
    {
      MessageBox(NULL, "Not found resource", "Error", MB_OK);
      return NULL;
    }

  // get resource size
  DWORD Size = SizeofResource(hinst, hRes);

  if (Size == 0)
    {
      MessageBox(NULL, "Resource size = 0", "Error", MB_OK);
      return NULL;
    }


  HGLOBAL hData = LoadResource(hinst, hRes);

  if (hData == NULL)
    {
      MessageBox(NULL, "Failure load resource", "Error", MB_OK);
      return NULL;
    }

  const void *pData = LockResource(hData);

  if (pData == NULL)
    {
      MessageBox(NULL, "Failure lock resource", "Error", MB_OK);
      return NULL;
    }

  // Copy resource data
  HGLOBAL hBuffer = GlobalAlloc(GMEM_MOVEABLE, Size);

  if (hBuffer == NULL)
    {
      MessageBox(NULL, "Failure alloc", "Error", MB_OK);
      return NULL;
    }

  void *pBuffer = GlobalLock(hBuffer);

  if (pBuffer == NULL)
    {
      MessageBox(NULL, "Failure lock", "Error", MB_OK);
      GlobalFree(hBuffer);
      return NULL;
    }

  CopyMemory(pBuffer, pData, Size);
  GlobalUnlock(hBuffer);

  // read image
  IStream *pStream;

  if (CreateStreamOnHGlobal(hBuffer, TRUE, &pStream) != S_OK)
    {
      MessageBox(NULL, "Failure create stream", "Error", MB_OK);
      GlobalFree(hBuffer);
      return NULL;
    }

  Bitmap *pBitmap = Bitmap::FromStream(pStream);
  pStream->Release();

  return pBitmap;
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  HDC hdc;
  PAINTSTRUCT ps;
  
  static Bitmap* img;
  static Bitmap* bg;
  static Bitmap* offScrnBmp;

  static Graphics* onScrn;
  static Graphics* offScrn;

  RECT rect;

  static float x, y, dx, dy;
  static int wdw_w, wdw_h;

  switch (uMsg)
    {
    case WM_CREATE:
      // get window size
      GetClientRect(hWnd, &rect);
      wdw_w = rect.right - rect.left;
      wdw_h = rect.bottom - rect.top;

      // create off screen bitmap
      offScrnBmp = new Bitmap(wdw_w, wdw_h);

      // Load image from resource
      img = LoadImageFromResource(hInst, MAKEINTRESOURCE(IDI_BALL), RT_RCDATA);
      bg = LoadImageFromResource(hInst, MAKEINTRESOURCE(IDI_BG), RT_RCDATA);

      // not work
      // img = LoadImageFromResource(hInst, TEXT("IDI_BALL"), TEXT("RCDATA"));
      // bg = LoadImageFromResource(hInst, TEXT("IDI_BG"), TEXT("RCDATA"));

      if (img != NULL && bg != NULL)
        {
          x = (float)(wdw_w / 2);
          y = (float)(wdw_h / 2);
          dx = (float) wdw_w / (float)FPS;
          dy = dx * 0.5;

          SetTimer(hWnd, TM_COUNT1, (int)(1000 / FPS), NULL);
        }

      break;

    case WM_TIMER:
      // main loop
      x += dx;
      y += dy;

      if (x <= 0 || x + img->GetWidth() >= wdw_w) dx *= -1;

      if (y <= 0 || y + img->GetHeight() >= wdw_h) dy *= -1;

      // InvalidateRect(hWnd, NULL, TRUE);
      InvalidateRect(hWnd, NULL, FALSE);  // not clear background
      break;

    case WM_PAINT:
      // draw image to off screen
      offScrn = new Graphics(offScrnBmp);
      
      if (bg != NULL)
        offScrn->DrawImage(bg, 0, 0, bg->GetWidth(), bg->GetHeight());

      if (img != NULL)
        offScrn->DrawImage(img, (int)x, (int)y, img->GetWidth(), img->GetHeight());

      delete (offScrn);

      // draw off screen to window
      hdc = BeginPaint(hWnd, &ps);
      
      onScrn = new Graphics(hdc);
      onScrn->DrawImage(offScrnBmp, 0, 0, offScrnBmp->GetWidth(), offScrnBmp->GetHeight());
      delete(onScrn);
      
      EndPaint(hWnd, &ps);
      
      break;

    case WM_DESTROY:
      delete (img);
      delete (bg);
      delete (offScrnBmp);

      PostQuitMessage(0);
      break;

    default:
      return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

  return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
  MSG msg;
  GdiplusStartupInput gpSI;
  ULONG_PTR lpToken;

  hInst = hInstance;

  /* GDI+初期化 */
  GdiplusStartup(&lpToken, &gpSI, NULL);

  HCURSOR hCursor = LoadCursor(NULL, IDC_ARROW);
  HBRUSH hBrush = (HBRUSH)(COLOR_WINDOW + 1);
  WNDCLASS wcl = { 0, WndProc, 0, 0, hInst, NULL, hCursor, hBrush, NULL, "mh" };
  DWORD style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

  if (!RegisterClass(&wcl) ||
      !CreateWindowEx(0, "mh", "gdiplus test",
                      style,
                      CW_USEDEFAULT, CW_USEDEFAULT,
                      SCRW, SCRH,
                      NULL, NULL, hInst, NULL))
    return FALSE;

  while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

  /* GDI+終了 */
  GdiplusShutdown(lpToken);

  return msg.wParam;
}

windres res.rc res.o
g++ -c 03_gdiplus_dbuf.cpp
g++ 03_gdiplus_dbuf.o res.o -o 03_gdiplus_dbuf.exe -mwindows -static -lstdc++ -lgcc -lgdiplus -lgdi32 -lole32

BALL_IMG        BITMAP  "ball.bmp"
BALL_MSK        BITMAP  "ball_mask.bmp"
BG_IMG          BITMAP  "bg2.bmp"

• 3つのbmp画像ファイルを含めるように指定している。
• 先頭に書かれている「BALL_IMG」「BALL_MSK」「BG_IMG」が、C言語のソース内で指定する識別名。

• ball.bmp : 赤いボール画像。透明にしたい部分は黒(#000000)にしておく。
• ball_mask.bmp : ボール画像のマスク画像。不透明部分は黒(#000000)、透明部分は白(#ffffff)。アルファチャンネルを反転した感じの画像。
• bg2.bmp : 背景用画像。タイル状に描画することを前提にしている。

/* GDI Double buffer sample */

#include <windows.h>

#define SCRW        1280
#define SCRH        720

#define FPS         60

#define TM_COUNT1   101

#define LPCLASSNAME     TEXT("DoubleBufferSample")
#define WINDOW_TITLE    TEXT("Double Buffer Sample")


LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
  static HBITMAP hBitmap;
  static HBITMAP hBitmap_mask;
  static HBITMAP hBitmap_bg;
  static HBITMAP offScrnBitmap;
  static int wdw_w, wdw_h;
  static int imgw, imgh;
  static int bgw, bgh;
  static int bgx, bgy;
  static float x, y;
  static float dx, dy;

  switch (msg)
    {
    case WM_CREATE:
      // get window size
      {
        RECT rc;
        GetClientRect(hwnd, &rc);
        wdw_w = rc.right - rc.left;
        wdw_h = rc.bottom - rc.top;
      }

      // create off screen bitmap
      {
        HDC hdc;
        hdc = GetDC(hwnd);
        offScrnBitmap = CreateCompatibleBitmap(hdc, wdw_w, wdw_h);
        ReleaseDC(hwnd, hdc);    // GetDC() -> ReleaseDC()
      }

      // load bitmaps from resource
      hBitmap = LoadBitmap(((LPCREATESTRUCT)lp)->hInstance, TEXT("BALL_IMG"));
      hBitmap_mask = LoadBitmap(((LPCREATESTRUCT)lp)->hInstance, TEXT("BALL_MSK"));
      hBitmap_bg = LoadBitmap(((LPCREATESTRUCT)lp)->hInstance, TEXT("BG_IMG"));

      // get images size
      {
        BITMAP bp;

        // get ball image size
        GetObject(hBitmap, sizeof(BITMAP), &bp);
        imgw = bp.bmWidth;
        imgh = bp.bmHeight;

        // get bg image size
        GetObject(hBitmap_bg, sizeof(BITMAP), &bp);
        bgw = bp.bmWidth;
        bgh = bp.bmHeight;
      }

      // init work
      x = wdw_w / 2;
      y = wdw_h / 2;
      dx = (float)wdw_w / (float)FPS;
      dy = dx * 0.2;
      bgx = 0;
      bgy = 0;

      SetTimer(hwnd, TM_COUNT1, (int)(1000 / FPS), NULL);
      return 0;

    case WM_TIMER:
      // main loop
      x += dx;
      y += dy;

      if (x <= 0 || (x + imgw) >= wdw_w) dx *= -1;

      if (y <= 0 || (y + imgh) >= wdw_h) dy *= -1;

      bgx -= 1;
      bgy -= 1;

      if (bgx <= -(bgw)) bgx += bgw;

      if (bgy <= -(bgh)) bgy += bgh;

      if (0)
        {
          // clear background
          InvalidateRect(hwnd, NULL, TRUE);
        }
      else
        {
          // not clear background
          InvalidateRect(hwnd, NULL, FALSE);
        }

      break;

    case WM_PAINT:
      // draw window
      {
        HDC hdc, hBmpDC, hMemDC;
        PAINTSTRUCT ps;

        hdc = BeginPaint(hwnd, &ps);
        // hdc = GetDC(hwnd);

        // set off-screen bitmap
        hMemDC = CreateCompatibleDC(hdc);
        SelectObject(hMemDC, offScrnBitmap);

        // draw bg to off-screen
        hBmpDC = CreateCompatibleDC(hdc);
        SelectObject(hBmpDC, hBitmap_bg);
        {
          int by = bgy;

          while (by <= wdw_h)
            {
              int bx = bgx;

              while (bx <= wdw_w)
                {
                  BitBlt(hMemDC, bx, by, bgw, bgh, hBmpDC, 0, 0, SRCCOPY);
                  bx += bgw;
                }

              by += bgh;
            }
        }
        DeleteDC(hBmpDC);

        // draw mask to off-screen
        hBmpDC = CreateCompatibleDC(hdc);
        SelectObject(hBmpDC, hBitmap_mask);
        BitBlt(hMemDC, (int)x, (int)y, imgw, imgh, hBmpDC, 0, 0, SRCAND);
        DeleteDC(hBmpDC);

        // draw source image to off-screen
        hBmpDC = CreateCompatibleDC(hdc);
        SelectObject(hBmpDC, hBitmap);
        BitBlt(hMemDC, (int)x, (int)y, imgw, imgh, hBmpDC, 0, 0, SRCPAINT);
        DeleteDC(hBmpDC);

        // drawing to off-screen is finished

        // draw off-screen bitmap to window
        BitBlt(hdc, 0, 0, wdw_w, wdw_h, hMemDC, 0, 0, SRCCOPY);

        DeleteDC(hMemDC);     // Create*() -> DeleteDC()

        EndPaint(hwnd, &ps);
      }

      return 0;

    case WM_DESTROY:
      KillTimer(hwnd, TM_COUNT1);  // kill timer

      DeleteObject(offScrnBitmap);
      DeleteObject(hBitmap);
      DeleteObject(hBitmap_mask);
      DeleteObject(hBitmap_bg);
      PostQuitMessage(0);
      return 0;
    }

  return DefWindowProc(hwnd, msg, wp, lp);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR lpCmdLine, int nCmdShow)
{
  HWND hwnd;
  MSG msg;
  WNDCLASS winc;

  winc.style            = CS_HREDRAW | CS_VREDRAW;
  winc.lpfnWndProc      = WndProc;
  winc.cbClsExtra       = winc.cbWndExtra   = 0;
  winc.hInstance        = hInstance;
  winc.hIcon            = LoadIcon(NULL, IDI_APPLICATION);
  winc.hCursor          = LoadCursor(NULL, IDC_ARROW);
  winc.hbrBackground    = (HBRUSH)GetStockObject(WHITE_BRUSH);
  winc.lpszMenuName     = NULL;
  winc.lpszClassName    = LPCLASSNAME;

  if (!RegisterClass(&winc)) return -1;

  hwnd = CreateWindow(
    LPCLASSNAME, WINDOW_TITLE,
    WS_OVERLAPPEDWINDOW | WS_VISIBLE,
    CW_USEDEFAULT, CW_USEDEFAULT,
    SCRW, SCRH,
    NULL, NULL,
    hInstance, NULL
    );

  if (hwnd == NULL) return -1;

  while (GetMessage(&msg, NULL, 0, 0))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

  return msg.wParam;
}

• SetTimer() で指定したミリ秒が経過すると、その都度、WM_TIMER というメッセージが Windows から送られてくる。
• WM_TIMER が来た時に、ボールやBG画像の表示位置を更新することで、アニメーションをさせている。
• InvalidateRect() を呼べば、ウインドウの再描画を要求できる。(WM_PAINTメッセージが送られてくる。)
• InvalidateRect(hwnd, NULL, TRUE); なら、背景を消去しつつ、ウインドウを再描画(するように要求)。
• InvalidateRect(hwnd, NULL, FALSE); なら、背景を消去せずに、ウインドウを再描画(するように要求)。ダブルバッファ描画をする時はこちらを指定する。
• WM_PAINT が来た時に、描画処理を行う。
• WM_DESTROY が来たら、終了処理を行う。タイマーを殺して、bitmap を全部削除しておく。

01_dblbuf.exe: 01_dblbuf.o res.o
        gcc 01_dblbuf.o res.o -o 01_dblbuf.exe -mwindows

01_dblbuf.o: 01_dblbuf.c
        gcc -c 01_dblbuf.c

res.o: res.rc ball.bmp ball_mask.bmp bg2.bmp
        windres res.rc res.o

.PHONY: clean
clean:
        rm -f *.exe
        rm -f *.o

• 01_dblbuf.c
• ball.bmp
• ball_mask.bmp
• bg2.bmp
• Makefile
• res.rc

• GetDC() を使って取得したデバイスコンテキストは、ReleaseDC() を使って解放する。
• Create*() を使って取得したデバイスコンテキストは、DeleteDC() を使って解放する。

/* resource.rc */

#include <windows.h>
#include <scrnsave.h>

#define IDC_STATIC_ICON     2300
#define IDC_STATIC_TEXT     2301

/* bitmap */
IDI_BALL        BITMAP  "ball.bmp"
IDI_BALL_MSK    BITMAP  "ball_mask.bmp"
IDI_BG          BITMAP  "bg2.bmp"
IDI_PREVIEW     BITMAP  "scrsav_preview.bmp"

/* Config dialog */
DLG_SCRNSAVECONFIGURE DIALOG DISCARDABLE  0, 0, 220, 50
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "Setting Sample Screensaver"
 FONT 9, "Segoe UI"
BEGIN
  DEFPUSHBUTTON "OK", IDOK, 85, 30, 50, 14
  ICON          IDI_WARNING, IDC_STATIC_ICON, 6, 5, 20, 20
  LTEXT         "This is the template for the configuration dialog.", 
                IDC_STATIC_TEXT, 35, 12, 230, 12
END

#ifndef RESOURCE_H_
#define RESOURCE_H_

#define IDC_STATIC_ICON     2300
#define IDC_STATIC_TEXT     2301

#define IDI_BALL            2401
#define IDI_BALL_MSK        2402
#define IDI_BG              2403

#endif

• ball.bmp : 赤いボール画像。透明部分は黒(#000000)にしておく。
• ball_mask.bmp : ボールのマスク画像。不透明部分は黒(#000000)、透明部分は白(#ffffff)。
• bg2.bmp : bg画像(背景画像)。タイル状に描画することを前提にしている。
• scrsav_preview.bmp : プレビュー画像。スクリーンセーバの設定画面で表示されてる小さい窓の中に表示するための画像。サイズは 152 x 112 ドット。

/* mingwscr.c */

#include <windows.h>
#include <tchar.h>
#include <scrnsave.h>
#include <time.h>
#include <stdlib.h>

#define FPS        60

#define ID_TIMER   101


/* screensaver main processing */
LRESULT WINAPI ScreenSaverProc(HWND hWnd, UINT msg,
                               WPARAM wParam, LPARAM lParam)
{
  static HBITMAP hBitmap;
  static HBITMAP hBitmap_mask;
  static HBITMAP hBitmap_bg;
  static HBITMAP hBitmap_preview;
  static HBITMAP offScrnBitmap;

  static int wdw_w, wdw_h;
  static int imgw, imgh;
  static int bgw, bgh;
  static int pvw, pvh;
  static float x, y, dx, dy, bgx, bgy;
  int bx, by;

  switch (msg)
    {
    case WM_CREATE:
      /* initialize */

      // get window size
      {
        RECT rc;

        GetClientRect(hWnd, &rc);
        wdw_w = rc.right - rc.left;
        wdw_h = rc.bottom - rc.top;
      }

      // create off-screen bitmap
      {
        HDC hdc;

        hdc = GetDC(hWnd);
        offScrnBitmap = CreateCompatibleBitmap(hdc, wdw_w, wdw_h);
        ReleaseDC(hWnd, hdc);
      }

      // load bitmaps
      hBitmap = LoadBitmap(((LPCREATESTRUCT)lParam)->hInstance, TEXT("IDI_BALL"));
      hBitmap_mask = LoadBitmap(((LPCREATESTRUCT)lParam)->hInstance, TEXT("IDI_BALL_MSK"));
      hBitmap_bg = LoadBitmap(((LPCREATESTRUCT)lParam)->hInstance, TEXT("IDI_BG"));
      hBitmap_preview = LoadBitmap(((LPCREATESTRUCT)lParam)->hInstance, TEXT("IDI_PREVIEW"));

      // get images size
      {
        BITMAP bp;

        // get ball image size
        GetObject(hBitmap, sizeof(BITMAP), &bp);
        imgw = bp.bmWidth;
        imgh = bp.bmHeight;

        // get bg image size
        GetObject(hBitmap_bg, sizeof(BITMAP), &bp);
        bgw = bp.bmWidth;
        bgh = bp.bmHeight;

        // get preview image size
        GetObject(hBitmap_preview, sizeof(BITMAP), &bp);
        pvw = bp.bmWidth;
        pvh = bp.bmHeight;
      }

      // init work
      x = wdw_w / 2;
      y = wdw_h / 2;
      dx = (float)wdw_w / (float)FPS;
      dy = dx * 0.5;
      bgx = 0;
      bgy = 0;

      // create timer
      SetTimer(hWnd, ID_TIMER, (int)(1000 / FPS), NULL);
      break;

    case WM_TIMER:
      /* main loop */

      // update ball position
      x += dx;
      y += dy;

      if (x <= 0 || x + imgw >= wdw_w) dx *= -1;

      if (y <= 0 || y + imgh >= wdw_h) dy *= -1;

      // update bg position
      bgx -= 2;
      bgy -= 2;

      if (bgx <= -bgw) bgx += bgw;

      if (bgy <= -bgh) bgy += bgh;

      // draw bitmap

      if (wdw_w >= 160)
        {
          // draw fullscreen

          HDC hdc, hBmpDC, hMemDC;

          hdc = GetDC(hWnd);

          // set off-screen bitmap
          hMemDC = CreateCompatibleDC(hdc);
          SelectObject(hMemDC, offScrnBitmap);

          // draw bg to off-screen
          hBmpDC = CreateCompatibleDC(hdc);
          SelectObject(hBmpDC, hBitmap_bg);
          {
            int by = bgy;

            while (by <= wdw_h)
              {
                int bx = bgx;

                while (bx <= wdw_w)
                  {
                    BitBlt(hMemDC, bx, by, bgw, bgh, hBmpDC, 0, 0, SRCCOPY);
                    bx += bgw;
                  }

                by += bgh;
              }
          }
          DeleteDC(hBmpDC);

          // draw ball mask to off-screen
          hBmpDC = CreateCompatibleDC(hdc);
          SelectObject(hBmpDC, hBitmap_mask);
          BitBlt(hMemDC, (int)x, (int)y, imgw, imgh, hBmpDC, 0, 0, SRCAND);
          DeleteDC(hBmpDC);

          // draw ball source to off-screen
          hBmpDC = CreateCompatibleDC(hdc);
          SelectObject(hBmpDC, hBitmap);
          BitBlt(hMemDC, (int)x, (int)y, imgw, imgh, hBmpDC, 0, 0, SRCPAINT);
          DeleteDC(hBmpDC);

          // drawing to off-screen is finished

          // draw off-screen bitmap to window
          BitBlt(hdc, 0, 0, wdw_w, wdw_h, hMemDC, 0, 0, SRCCOPY);

          DeleteDC(hMemDC);      // Create*() -> DeleteDC()
          ReleaseDC(hWnd, hdc);  // GetDC() -> ReleaseDC()
        }
      else
        {
          // draw preview
          HDC hdc, hBmpDC;
          hdc = GetDC(hWnd);
          hBmpDC = CreateCompatibleDC(hdc);
          SelectObject(hBmpDC, hBitmap_preview);
          BitBlt(hdc, 0, 0, pvw, pvh, hBmpDC, 0, 0, SRCCOPY);
          DeleteDC(hBmpDC);      // Create*() -> DeleteDC()
          ReleaseDC(hWnd, hdc);  // GetDC() -> ReleaseDC()
        }

      break;

    case WM_DESTROY:
      KillTimer(hWnd, ID_TIMER);  // kill timer

      // delete bitmap
      DeleteObject(offScrnBitmap);
      DeleteObject(hBitmap);
      DeleteObject(hBitmap_mask);
      DeleteObject(hBitmap_bg);
      DeleteObject(hBitmap_preview);

      PostQuitMessage(0);
      break;

    default:
      break;
    }

  return DefScreenSaverProc(hWnd, msg, wParam, lParam);
}

/* Processing of dialog boxes for configuration */
BOOL WINAPI ScreenSaverConfigureDialog(HWND hDlg, UINT msg,
                                       WPARAM wParam, LPARAM lParam)
{
  switch (msg)
    {
    case WM_INITDIALOG:
      MessageBox(
        hDlg,
        _T("This screen saver has no configuration options."),
        _T("Sample Screensaver by using MinGW"),
        MB_OK | MB_ICONWARNING);
      EndDialog(hDlg, IDOK);
      return TRUE;

    case WM_COMMAND:
      switch (LOWORD(wParam))
        {
        case IDOK:
          EndDialog(hDlg, IDOK);
          return TRUE;

        case IDCANCEL:
          EndDialog(hDlg, IDCANCEL);
          return TRUE;
        }

      return FALSE;
    }

  return FALSE;
}

/* Register non-standard window classes required by dialog boxes for configuration */
BOOL WINAPI RegisterDialogClasses(HANDLE hInst)
{
  return TRUE;
}

mgscrsv2.scr: mgscrsv2.o resource.o
        gcc mgscrsv2.o resource.o -o mgscrsv2.scr -mwindows -lscrnsave

mgscrsv2.o: mgscrsv2.c
        gcc -c mgscrsv2.c

resource.o: resource.rc resource.h ball.bmp ball_mask.bmp bg2.bmp scrsav_preview.bmp
        windres resource.rc -o resource.o

.PHONY: clean
clean:
        rm -f *.scr
        rm -f *.o

• Windows用プログラムなので、-mwindows を渡している。
• スクリーンセーバを作るので、-lscrnsave を渡して「libscrnsave.a (or libscrnsavw.a) をリンクせよ」と指定している。

• ball.bmp
• ball_mask.bmp
• bg2.bmp
• Makefile
• mgscrsv2.c
• resource.h
• resource.rc
• scrsav_preview.bmp

• 「Test」を選べば、フルスクリーン表示時の動作確認ができる。
• 「構成」を選べば、スクリーンセーバの設定画面で「設定」をクリックした時の動作を確認できる。

• Windows が 64bit版、スクリーンセーバが32bit版なら、C:\Windows\SysWOW64\ に .scr をコピー。
• Windows が 64bit版、スクリーンセーバが64bit版なら、C:\Windows\System32\ に .scr をコピー。
• Windows が 32bit版なら、C:\Windows\System32\ 以下に .scr をコピー。

• コンソールプログラム(DOS窓上で使う感じのプログラム)なら、main() という名前の関数が必要。
• GUIアプリなら、WinMain() という名前の関数が必要。

• ScreenSaverProc()
• ScreenSaverConfigureDialog()
• RegisterDialogClasses()

• IDS_DESCRIPTION (値は 1) : スクリーンセーバの名前/タイトルを示す。
• ID_APP (値は 100) : スクリーンセーバのアイコンを示す。
• DLG_SCRNSAVECONFIGURE (値は 2003) : スクリーンセーバの設定ダイアログを示す。

• IDS_DESCRIPTION は、"MinGW Scrnsave Sample" にした。これは、スクリーンセーバ設定画面のリスト一覧上の名前になる。
• ID_APP は、ICON "appli.ico" に。
• DLG_SCRNSAVECONFIGURE には、OKボタンとキャンセルボタンを並べた。

/* resource.rc */

#include <windows.h>
#include <scrnsave.h>

#define IDC_STATIC_ICON     2300
#define IDC_STATIC_TEXT     2301

/* bitmap */
IDI_BALL        BITMAP  "ball.bmp"
IDI_BALL_MSK    BITMAP  "ball_mask.bmp"
IDI_BG          BITMAP  "bg2.bmp"
IDI_PREVIEW     BITMAP  "scrsav_preview.bmp"

/* screensaver title */
STRINGTABLE
BEGIN
  IDS_DESCRIPTION       "MinGW Scrnsave Sample"
END

/* Icon */
ID_APP  ICON    "appli.ico"

/* Config dialog */
DLG_SCRNSAVECONFIGURE DIALOG DISCARDABLE  0, 0, 260, 80
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "Setting Sample Screensaver"
 FONT 11, "Segoe UI"
BEGIN
  DEFPUSHBUTTON "OK", IDOK, 140, 58, 50, 16
  PUSHBUTTON "Cancel", IDCANCEL, 200, 58, 50, 16
  ICON IDI_WARNING, IDC_STATIC_ICON, 8, 8, 20, 20
  LTEXT "This is the template for the configuration dialog.", IDC_STATIC_TEXT, 32, 8, 230, 25
END

#include <windows.h>
#include <tchar.h>
#include <scrnsave.h>
#include <time.h>
#include <stdlib.h>
#include "resource.h"

/* ... */

/* Processing of dialog boxes for configuration */
BOOL WINAPI ScreenSaverConfigureDialog(HWND hDlg, UINT msg,
                                       WPARAM wParam, LPARAM lParam)
{
  switch (msg)
    {
    case WM_COMMAND:
      switch (LOWORD(wParam))
        {
        case IDOK:
          EndDialog(hDlg, 0);
          return TRUE;

        case IDCANCEL:
          EndDialog(hDlg, 1);
          return TRUE;
        }

      return FALSE;
    }

  return FALSE;
}

/* Register non-standard window classes required by dialog boxes for configuration */
BOOL WINAPI RegisterDialogClasses(HANDLE hInst)
{
  return TRUE;
}

• 何のファイルも開かない状態で、Action → Add using Script Template、を選ぶと、DIALOG の雛形がエディタ画面に挿入される。
• ツールバー上の Compile Script (緑色の再生ボタン)をクリックするか、F5キーを叩けば、どんな見た目になるか表示される。
• 表示されたダイアログ上で右クリックして Insert Control を選べば、ウィジェットを追加していける。

bin/freeglut.dll

include/GL/freeglut.h
include/GL/freeglut_ext.h
include/GL/freeglut_std.h
include/GL/glut.h

lib/libfreeglut.a
lib/libfreeglut_static.a

#include <stdlib.h>
#include <GL/glut.h>

/* Keyboard callback function */
void keyboard(unsigned char key, int x, int y)
{
  switch (key)
    {
      /* Exit on escape key press */
      case '\x1B':
      {
        exit(EXIT_SUCCESS);
        break;
      }
    }
}

/* Display callback function */
void display()
{
  glClear(GL_COLOR_BUFFER_BIT);

  /* Display a red square */
  glColor3f(1.0f, 0.0f, 0.0f);

  glBegin(GL_POLYGON);
  glVertex2f(-0.5f, -0.5f);
  glVertex2f(0.5f, -0.5f);
  glVertex2f(0.5f,  0.5f);
  glVertex2f(-0.5f,  0.5f);
  glEnd();

  glFlush();
}

/* Main method */
int main(int argc, char** argv)
{
  glutInit(&argc, argv);

  /* Create a single window with a keyboard and display callback */
  glutCreateWindow("GLUT Test");
  glutKeyboardFunc(&keyboard);
  glutDisplayFunc(&display);

  /* Run the GLUT event loop */
  glutMainLoop();

  return EXIT_SUCCESS;
}

# スタティックリンクしない場合。

gcc hello_glut.c -o hello_glut.exe -lfreeglut -lopengl32 -lwinmm -lgdi32 -mwindows

# スタティックリンクする場合。

gcc hello_glut.c -o hello_glut.exe -D FREEGLUT_STATIC -lfreeglut_static -lopengl32 -lwinmm -lgdi32 -mwindows

• スタティックリンクしない場合は、実行ファイルのサイズは小さくなるけれど、動作には freeglut.dll が必要になる。
• スタティックリンクする場合は、実行ファイルが freeglut.dll の中身を含んでいるので、freeglut.dll が無くても動く。ファイルサイズは少し大きくなる。

• greensquare.cpp
• icon.ico
• Makefile
• resource.h
• resource.rc

/* resource.rc */

#include <windows.h>
#include <scrnsave.h>
#include "resource.h"

#define IDC_STATIC_ICON     2300
#define IDC_STATIC_TEXT     2301

/* LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US */

/* Screensaver title */
STRINGTABLE
BEGIN
  IDS_DESCRIPTION       "Green Square Example Scr"
END

/* Icon */
ID_APP  ICON    "icon.ico"

/* Dialog */
DLG_SCRNSAVECONFIGURE DIALOG DISCARDABLE  0, 0, 186, 82
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "GreenSquare Setup"
 FONT 11, "Segoe UI"
BEGIN
  DEFPUSHBUTTON "OK", IDOK, 39, 61, 50, 14 
  PUSHBUTTON    "Cancel", IDCANCEL, 107, 61, 50, 14
  AUTOCHECKBOX  "Square tumbles as it revolves", IDC_TUMBLE, 25, 35, 137, 12
  LTEXT "One option... that's all you get.", IDC_STATIC_TEXT, 17, 15, 150, 13
END

#ifndef _RESOURCE_H_
#define _RESOURCE_H_

#define IDC_TUMBLE 1000

#define IDC_STATIC_ICON     2300
#define IDC_STATIC_TEXT     2301

#endif

// greensquare.cpp is an open-source example screensaver by Rachel Grey, lemming@alum.mit.edu.
// Paste into an IDE to compile if desired.
// I haven't chosen to include the resource file, so you'd need to provide a description string /and so forth.

#include <windows.h>
#include <scrnsave.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "resource.h"

// get rid of these warnings: truncation from const double to float conversion from double to float
// #pragma warning(disable: 4305 4244)

//Define a Windows timer

#define TIMER 1

#define FPS 60

// globals for size of screen
static int Width, Height;

static bool bTumble = true;

// a global to keep track of the square's spinning
static GLfloat spin = 0;

/////////////////////////////////////////////////
////   INFRASTRUCTURE ENDS, SPECIFICS BEGIN   ///
////                                          ///
////    In a more complex scr, I'd put all    ///
////     the following into other files.      ///
/////////////////////////////////////////////////

// Initialize OpenGL
static void InitGL(HWND hWnd, HDC &hDC, HGLRC &hRC)
{
  PIXELFORMATDESCRIPTOR pfd;
  ZeroMemory(&pfd, sizeof pfd);
  pfd.nSize = sizeof pfd;
  pfd.nVersion = 1;
  //pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL; //blaine's
  pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
  pfd.iPixelType = PFD_TYPE_RGBA;
  pfd.cColorBits = 24;

  hDC = GetDC(hWnd);

  int i = ChoosePixelFormat(hDC, &pfd);
  SetPixelFormat(hDC, i, &pfd);

  hRC = wglCreateContext(hDC);
  wglMakeCurrent(hDC, hRC);
}

// Shut down OpenGL
static void CloseGL(HWND hWnd, HDC hDC, HGLRC hRC)
{
  wglMakeCurrent(NULL, NULL);
  wglDeleteContext(hRC);
  ReleaseDC(hWnd, hDC);
}


void SetupAnimation(int Width, int Height)
{
  //window resizing stuff
  glViewport(0, 0, (GLsizei) Width, (GLsizei) Height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  if (0)
    {
      glOrtho(-300, 300, -240, 240, 25, 75);
    }
  else
    {
      float w = 300;
      float h = ((w * 2) * Height / Width) / 2;
      glOrtho(-w, w, -h, h, 25, 75);
    }

  glMatrixMode(GL_MODELVIEW);

  glLoadIdentity();
  gluLookAt(0.0, 0.0, 50.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  //camera xyz, the xyz to look at, and the up vector (+y is up)

  //background
  glClearColor(0.0, 0.0, 0.0, 0.0); //0.0s is black

  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  // glShadeModel(GL_FLAT);
  glShadeModel(GL_SMOOTH);
}

void OnTimer(HDC hDC) //increment and display
{
  float xvals[] = {-30.0, -30.0, 30.0,  30.0};
  float yvals[] = {-30.0,  30.0, 30.0, -30.0};

  spin = spin + 1;

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();

  glRotatef(spin, 0.0, 0.0, 1.0);
  glTranslatef(120, 0, 0);
  glRotatef(spin * ((bTumble) ? -4.0 : -1.0), 0.0, 0.0, 1.0);

  //draw the square (rotated to be a diamond)

  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  glColor3f(0.1, 1.0, 0.3); // set green color

  glBegin(GL_POLYGON);

  for (int i = 0; i < 4; i++)
    glVertex2f(xvals[i], yvals[i]);

  glEnd();

  glPopMatrix();

  glFlush();
  SwapBuffers(hDC);
}

void CleanupAnimation()
{
  // didn't create any objects, so no need to clean them up
}


/////////   REGISTRY ACCESS FUNCTIONS     ///////////

void GetConfig()
{
  if (0)
    {
      // get configuration from registry

      HKEY key;
      //DWORD lpdw;

      if (RegOpenKeyEx(HKEY_CURRENT_USER,
                       "Software\\GreenSquare", //lpctstr
                       0,                       //reserved
                       KEY_QUERY_VALUE,
                       &key) == ERROR_SUCCESS)
        {
          DWORD dsize = sizeof(bTumble);
          DWORD dwtype =  0;

          RegQueryValueEx(key, "Tumble", NULL, &dwtype,
                          (BYTE*)&bTumble, &dsize);

          //Finished with key
          RegCloseKey(key);
        }
      else //key isn't there yet--set defaults
        {
          bTumble = true;
        }
    }
  else
    {
      bTumble = true;
    }
}

void WriteConfig(HWND hDlg)
{
  if (0)
    {
      HKEY key;
      DWORD lpdw;

      const char* null_str = "";
      LPSTR str = const_cast<LPSTR>(null_str);

      if (RegCreateKeyEx(HKEY_CURRENT_USER,
                         "Software\\GreenSquare", // lpctstr
                         0,                       // reserved
                         str,                     // ptr to null-term string specifying the object type of this key
                         REG_OPTION_NON_VOLATILE,
                         KEY_WRITE,
                         NULL,
                         &key,
                         &lpdw) == ERROR_SUCCESS)

        {
          RegSetValueEx(key, "Tumble", 0, REG_DWORD,
                        (BYTE*)&bTumble, sizeof(bTumble));

          //Finished with keys
          RegCloseKey(key);
        }
    }
}

//////////////////////////////////////////////////
////   INFRASTRUCTURE -- THE THREE FUNCTIONS   ///
//////////////////////////////////////////////////

// Screen Saver Procedure
LRESULT WINAPI ScreenSaverProc(HWND hWnd, UINT message,
                               WPARAM wParam, LPARAM lParam)
{
  static HDC hDC;
  static HGLRC hRC;
  static RECT rect;

  switch (message)
    {
      case WM_CREATE:
        // get window dimensions
        GetClientRect(hWnd, &rect);
        Width = rect.right;
        Height = rect.bottom;

        // get configuration from registry
        GetConfig();

        // setup OpenGL, then animation
        InitGL(hWnd, hDC, hRC);
        SetupAnimation(Width, Height);

        // set timer to tick every 10 ms
        SetTimer(hWnd, TIMER, (int)(1000 / FPS), NULL);
        return 0;

      case WM_TIMER:
        OnTimer(hDC);       // animate!
        return 0;

      case WM_DESTROY:
        KillTimer(hWnd, TIMER);
        CleanupAnimation();
        CloseGL(hWnd, hDC, hRC);
        return 0;
    }

  return DefScreenSaverProc(hWnd, message, wParam, lParam);
}

BOOL WINAPI ScreenSaverConfigureDialog(HWND hDlg, UINT message,
                                       WPARAM wParam, LPARAM lParam)
{
  //InitCommonControls();
  //would need this for slider bars or other common controls

  HWND aCheck;

  switch (message)
    {
      case WM_INITDIALOG:
        LoadString(hMainInstance, IDS_DESCRIPTION, szAppName, 40);

        GetConfig();

        aCheck = GetDlgItem(hDlg, IDC_TUMBLE);
        SendMessage(aCheck, BM_SETCHECK, (bTumble) ? BST_CHECKED : BST_UNCHECKED, 0);
        return TRUE;

      case WM_COMMAND:
        switch (LOWORD(wParam))
          {
            case IDC_TUMBLE:
              bTumble = (IsDlgButtonChecked(hDlg, IDC_TUMBLE) == BST_CHECKED);
              return TRUE;

            //cases for other controls would go here

            case IDOK:
              WriteConfig(hDlg);  // get info from controls
              EndDialog(hDlg, LOWORD(wParam) == IDOK);
              return TRUE;

            case IDCANCEL:
              EndDialog(hDlg, LOWORD(wParam) == IDOK);
              return TRUE;
          }

        return FALSE;
    }  //end command switch

  return FALSE;
}

// needed for SCRNSAVE.LIB
BOOL WINAPI RegisterDialogClasses(HANDLE hInst)
{
  return TRUE;
}

greensquare.scr: greensquare.o resource.o
        g++ greensquare.o resource.o -o greensquare.scr -static -lstdc++ -lgcc -lscrnsave -lopengl32 -lglu32 -lgdi32 -lcomctl32 -lwinmm -mwindows

greensquare.o: greensquare.cpp resource.h
        g++ -c greensquare.cpp

resource.o: resource.rc resource.h icon.ico
        windres resource.rc resource.o

.PHONY: clean
clean:
        rm -f *.scr
        rm -f *.o

• windres resource.rc resource.o で、リソースファイル resource.rc を .o に変換する。
• g++ -c greensquare.cpp で、.cpp をコンパイルして .o を生成。
• g++ greensquare.o resource.o -o greensquare.scr ... で、.oファイル群をリンクして .scr を生成。

• -static : スタティックリンクを指定。
• -lstdc++ -lgcc : C言語の標準的なライブラリをリンク。
• -lscrnsave : スクリーンセーバ用ライブラリをリンク。libscrnsave.a (libscrnsavw.a) をリンクする。
• -lopengl32 -lglu32 : OpenGLのライブラリをリンク。
• -lgdi32 : GDIライブラリをリンク。
• -lcomctl32 : よく分かってないけれど、これをつけないと「*.dll が見つからない」と言われて .scr が動作しなかった。
• -lwinmm : Windowsのタイマー関係ライブラリ、らしい。
• -mwindows : Windows用アプリケーション(GUIアプリ)であることを指定。

• 「Test」を選ぶと、フルスクリーン表示の動作確認ができる。
• 「構成」を選ぶと、スクリーンセーバ設定画面で「設定」をクリックした時の設定ダイアログが表示される。

• PyOpenGL-3.1.6-cp39-cp39-win_amd64.whl
• PyOpenGL_accelerate-3.1.6-cp39-cp39-win_amd64.whl

pip install PyOpenGL-3.1.6-cp39-cp39-win_amd64.whl
pip install PyOpenGL_accelerate-3.1.6-cp39-cp39-win_amd64.whl

(Python3インストールフォルダ)\Lib\site-packages\OpenGL\DLLS\

• freeglut64.vc16.dll
• gle64.vc16.dll

• freeglut32.vc9.dll
• gle32.vc9.dll
• glut32.vc9.dll

(Python3インストールフォルダ)\Lib\site-packages\OpenGL\platform\win32.py

    def GLUT( self ):
        for possible in ('freeglut%s.%s'%(size,vc,), 'glut%s.%s'%(size,vc,)):
            # Prefer FreeGLUT if the user has installed it, fallback to the included
            # GLUT if it is installed
            try:
                return ctypesloader.loadLibrary(
                    ctypes.windll, possible, mode = ctypes.RTLD_GLOBAL
                )
            except WindowsError:
                pass
        return None

        for possible in ('freeglut%s.%s'%(size,vc,), 'glut%s.%s'%(size,vc,)):
# ↓
        for possible in ('freeglut', 'freeglut%s.%s' % (size,vc), 'glut%s.%s' % (size,vc)):

(Python3インストールフォルダ)\Lib\site-packages\OpenGL\DLLS\
or
(Python3インストールフォルダ)\

(MSYS2インストールフォルダ)\mingw64\bin\libfreeglut.dll

> py 03_teapot_draw_idle.py
Traceback (most recent call last):
  File "C:\Python\Python39-64\lib\site-packages\OpenGL\GLUT\special.py", line 130, in safeCall
    return function( *args, **named )
TypeError: idle() missing 1 required positional argument: 'value'
 GLUT Idle callback <function idle at 0x000002A6438D8B80> with (),{} failed: returning None idle() missing 1 required positional argument: 'value'

def on_timer(value):
    """timer callback."""
    global yrot
    yrot += 0.5
    glutPostRedisplay()  # Redraw

    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def idle():
    """idle callback."""
    global yrot
    yrot += 0.5
    glutPostRedisplay()  # Redraw

# ...

    if USE_IDLE:
        glutIdleFunc(idle)
    else:
        glutTimerFunc(int(1000 / FPS), on_timer, 0)

def _keyfunc(key, x, y):

    ESCAPE = "\x1b"
    # ESCAPE = b'\x1b'

    key = key.decode("ascii", "ignore")
    print("Push key,", key, x, y)

    if key == ESCAPE or key == "q":
        print("Exit")
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()

# ...

def main():

    # ...

    glutKeyboardFunc(_keyfunc)
    
    glutMainLoop()

pip install PyOpenGL-Demo

def keyboard(key, x, y):
    """ キーボードが押された時に呼ばれるコールバック関数. """
    global xspeed, yspeed

    # ESC key
    ESCAPE = b'\x1b'

    # ESCAPE = 27
    # ESCAPE = chr(27)
    # ESCAPE = '\033'
    # ESCAPE = "\x1b"
    
    if key == ESCAPE or key == b'q':
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()
    elif key == GLUT_KEY_UP:
        xspeed -= 0.1
    elif key == GLUT_KEY_DOWN:
        xspeed += 0.1
    elif key == GLUT_KEY_LEFT:
        yspeed -= 0.1
    elif key == GLUT_KEY_RIGHT:
        yspeed += 0.1
    elif key == b'l':  # 照明のオンオフ
        if glIsEnabled(GL_LIGHTING):
            glDisable(GL_LIGHTING)
        else:
            glEnable(GL_LIGHTING)

# ...

def main():

    # ...

    glutKeyboardFunc(keyboard)
    glutSpecialFunc(keyboard)

def _keyfunc(key, x, y):

    ESCAPE = "\x1b"
    # ESCAPE = b'\x1b'

    key = key.decode("ascii", "ignore")
    print("Push key,", key, x, y)

    if key == ESCAPE or key == "q":
        print("Exit")
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()

# ...

    glutKeyboardFunc(_keyfunc)

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys
from PIL import Image


IMGS = [
    "img_rgb.png",
    "img_rgba.png",
    "img_grayscale.png",
    "img_palette.png",
]

IMG_IDX = 0

SCRW, SCRH = 512, 512
FPS = 60
PANGLE = 60.0

window = 0

# Rotation angle for the Quads
rotx = 0.0
roty = 0.0

texture = 0


def load_texture():
    global texture

    # load image by using PIL
    im = Image.open(IMGS[IMG_IDX])
    w, h = im.size
    print("Image: %d x %d, %s" % (w, h, im.mode))

    if im.mode == "RGB":
        # RGB convert to RGBA
        im.putalpha(alpha=255)
    elif im.mode == "L" or im.mode == "P":
        # Grayscale, Index Color convert to RGBA
        im = im.convert("RGBA")

    raw_image = im.tobytes()

    ttype = GL_RGBA
    if im.mode == "RGB":
        ttype = GL_RGB
    elif im.mode == "RGBA":
        ttype = GL_RGBA

    glBindTexture(GL_TEXTURE_2D, glGenTextures(1))

    # glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4)

    # set texture
    glTexImage2D(
        GL_TEXTURE_2D,      # target
        0,                  # MIPMAP level
        ttype,              # texture type (RGB, RGBA)
        w,                  # texture image width
        h,                  # texture image height
        0,                  # border width
        ttype,              # texture type (RGB, RGBA)
        GL_UNSIGNED_BYTE,   # data is unsigne char
        raw_image,          # texture data pointer
    )

    glClearColor(0, 0, 0, 0)
    glShadeModel(GL_SMOOTH)

    # set texture repeat
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)

    # set texture filter
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)


def InitGL(width, height):
    glClearColor(0.125, 0.25, 0.5, 0.0)  # background color
    glClearDepth(1.0)  # Enables Clearing Of The Depth Buffer
    glDepthFunc(GL_LESS)  # The Type Of Depth Test To Do
    glEnable(GL_DEPTH_TEST)  # Enables Depth Testing
    glShadeModel(GL_SMOOTH)  # Enables Smooth Color Shading

    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()  # Reset The Projection Matrix

    # Calculate The Aspect Ratio Of The Window
    gluPerspective(PANGLE, float(width) / float(height), 0.1, 100.0)

    glMatrixMode(GL_MODELVIEW)


def ReSizeGLScene(width, height):
    # Prevent A Divide By Zero If The Window Is Too Small
    if height == 0:
        height = 1

    # Reset The Current Viewport And Perspective Transformation
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(PANGLE, float(width) / float(height), 0.1, 100.0)
    glMatrixMode(GL_MODELVIEW)


def DrawGLScene():
    global rotx, roty

    glClearColor(0.125, 0.25, 0.5, 0.0)  # background color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()  # Reset The View

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    glEnable(GL_BLEND)
    glEnable(GL_TEXTURE_2D)

    glPushMatrix()
    glTranslatef(0.0, 0.0, -2.0)  # translate

    # Rotate
    glRotatef(roty, 0.0, 1.0, 0.0)
    glRotatef(rotx, 1.0, 0.0, 0.0)

    glColor4f(1.0, 1.0, 1.0, 1.0)  # color

    # draw quads
    x, y, z = 1.0, 1.0, 0.0
    glBegin(GL_QUADS)

    glTexCoord2f(0.0, 0.0)  # set u, v
    glVertex3f(-x, y, z)  # Top Left

    glTexCoord2f(1.0, 0.0)
    glVertex3f(x, y, z)  # Top Right

    glTexCoord2f(1.0, 1.0)
    glVertex3f(x, -y, z)  # Bottom Right

    glTexCoord2f(0.0, 1.0)
    glVertex3f(-x, -y, z)  # Bottom Left

    glEnd()

    glPopMatrix()
    glDisable(GL_TEXTURE_2D)
    glDisable(GL_BLEND)

    glutSwapBuffers()


def on_timer(value):
    global rotx, roty
    rotx = -10.0
    roty = roty + 1.0
    glutPostRedisplay()
    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def keyPressed(key, x, y):
    # If escape is pressed, kill everything.
    ESCAPE = b"\x1b"
    if key == ESCAPE or key == b'q':
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()


def main():
    global window

    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(SCRW, SCRH)
    # glutInitWindowPosition(0, 0)

    window = glutCreateWindow(b"Draw texture")

    glutDisplayFunc(DrawGLScene)
    glutReshapeFunc(ReSizeGLScene)
    # glutFullScreen()

    # glutIdleFunc(DrawGLScene)
    glutTimerFunc(int(1000 / FPS), on_timer, 0)

    glutKeyboardFunc(keyPressed)
    InitGL(SCRW, SCRH)

    load_texture()

    glutMainLoop()


if __name__ == "__main__":
    print("Hit ESC key to quit.")
    main()

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys
from PIL import Image


IMGS = [
    [GL_TEXTURE0, "img_rgb.png"],
    [GL_TEXTURE1, "img_rgba.png"],
    [GL_TEXTURE2, "img_grayscale.png"],
    [GL_TEXTURE3, "img_palette.png"],
]

SCRW, SCRH = 512, 512
FPS = 60
PANGLE = 45.0

window = 0

# Rotation angle for the Quads
rotx = 0.0
roty = 0.0

textures = []


def load_texture(filename):
    # load image by using PIL
    im = Image.open(filename)
    w, h = im.size
    print("Image: %d x %d, %s" % (w, h, im.mode))

    if im.mode == "RGB":
        # RGB convert to RGBA
        im.putalpha(alpha=255)
    elif im.mode == "L" or im.mode == "P":
        # Grayscale and Index Color convert to RGBA
        im = im.convert("RGBA")

    raw_image = im.tobytes()

    ttype = GL_RGBA
    if im.mode == "RGB":
        ttype = GL_RGB
    elif im.mode == "RGBA":
        ttype = GL_RGBA

    id = glGenTextures(1)
    glBindTexture(GL_TEXTURE_2D, id)

    # glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4)

    # set texture
    glTexImage2D(
        GL_TEXTURE_2D,      # target
        0,                  # MIPMAP level
        ttype,              # texture type (RGB, RGBA)
        w,                  # texture image width
        h,                  # texture image height
        0,                  # border width
        ttype,              # texture type (RGB, RGBA)
        GL_UNSIGNED_BYTE,   # data is unsigne char
        raw_image,          # texture data pointer
    )

    glClearColor(0, 0, 0, 0)
    glShadeModel(GL_SMOOTH)

    # set texture repeat
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)

    # set texture filter
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)

    return id


def InitGL(width, height):
    glClearColor(0.15, 0.6, 0.3, 0.0)  # background color
    glClearDepth(1.0)  # Enables Clearing Of The Depth Buffer
    glDepthFunc(GL_LESS)  # The Type Of Depth Test To Do
    glEnable(GL_DEPTH_TEST)  # Enables Depth Testing
    glShadeModel(GL_SMOOTH)  # Enables Smooth Color Shading

    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()  # Reset The Projection Matrix

    # Calculate The Aspect Ratio Of The Window
    gluPerspective(PANGLE, float(width) / float(height), 0.1, 100.0)

    glMatrixMode(GL_MODELVIEW)


def ReSizeGLScene(width, height):
    # Prevent A Divide By Zero If The Window Is Too Small
    if height == 0:
        height = 1

    # Reset The Current Viewport And Perspective Transformation
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(PANGLE, float(width) / float(height), 0.1, 100.0)
    glMatrixMode(GL_MODELVIEW)


def DrawGLScene():
    global rotx, roty, textures

    glClearColor(0.15, 0.6, 0.3, 0.0)  # background color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()  # Reset The View

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    glEnable(GL_BLEND)
    glEnable(GL_TEXTURE_2D)

    r = 1.05
    poslist = [
        [-r, r],
        [r, r],
        [-r, -r],
        [r, -r],
    ]

    ry = roty
    for i, tex_id in enumerate(textures):
        tx, ty = poslist[i]

        glPushMatrix()

        # change texture
        glBindTexture(GL_TEXTURE_2D, tex_id)

        # translate
        glTranslatef(tx, ty, -6.0)

        # Rotate
        glRotatef(ry, 0.0, 1.0, 0.0)
        glRotatef(rotx, 1.0, 0.0, 0.0)

        glColor4f(1.0, 1.0, 1.0, 1.0)  # color

        # draw quads
        x, y, z = 1.0, 1.0, 0.0
        glBegin(GL_QUADS)

        glTexCoord2f(0.0, 0.0)  # set u, v
        glVertex3f(-x, y, z)  # Top Left

        glTexCoord2f(1.0, 0.0)
        glVertex3f(x, y, z)  # Top Right

        glTexCoord2f(1.0, 1.0)
        glVertex3f(x, -y, z)  # Bottom Right

        glTexCoord2f(0.0, 1.0)
        glVertex3f(-x, -y, z)  # Bottom Left

        glEnd()

        glPopMatrix()

        ry *= 1.2

    glDisable(GL_TEXTURE_2D)
    glDisable(GL_BLEND)

    glutSwapBuffers()


def on_timer(value):
    global rotx, roty
    rotx = 0.0
    roty = roty + 1.0
    glutPostRedisplay()
    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def keyPressed(key, x, y):
    # If escape is pressed, kill everything.
    ESCAPE = b"\x1b"
    if key == ESCAPE or key == b'q':
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()


def main():
    global window

    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(SCRW, SCRH)
    # glutInitWindowPosition(0, 0)

    window = glutCreateWindow(b"Draw textures")

    glutDisplayFunc(DrawGLScene)
    glutReshapeFunc(ReSizeGLScene)
    # glutFullScreen()

    # glutIdleFunc(DrawGLScene)
    glutTimerFunc(int(1000 / FPS), on_timer, 0)

    glutKeyboardFunc(keyPressed)
    InitGL(SCRW, SCRH)

    for _, fn in IMGS:
        id = load_texture(fn)
        textures.append(id)
        glEnable(GL_TEXTURE_2D)

    glutMainLoop()


if __name__ == "__main__":
    print("Hit ESC key to quit.")
    main()

• gimp-painter--2.6.11_100627-4_win32_starter.exe
• gimp-painter--2.6.11_100627-4_win32_update.exe

@echo off
set GIMPPATH=D:\Prog\GIMP-2.6.11-painter-\gimp-painter-
set PPATH=C:\Python\Python26

set PATH=%PPATH%;%PPATH%\Scripts;%PATH%
set PYTHONPATH=%PPATH%\Lib\site-packages
set PYTHON_ROOT=%PPATH%

echo.
echo Add path [%PPATH%]
echo Add path [%PPATH%\Scripts]
echo PYTHONPATH=%PYTHONPATH%
echo PYTHON_ROOT=%PYTHON_ROOT%
echo.

cd /d %GIMPPATH%
run_gimp.wsf

python=C:\Python\Python26\pythonw.exe
/usr/bin/python=C:\Python\Python26\pythonw.exe
:Python:E::py::python:

• GIMP 2.6インストール時に、Python 2.6.x が利用できる状態であること (Python 2.6にPATHが通っていること)。
• GIMP 2.6インストール時に、Python-Fu関係(GIMP-Python)のファイルもインストールすること。(「GIMP Python extension」にチェックを入れてインストール作業を進める。)
• GIMP 2.6起動時に、Python 2.6 が利用できる状態であること。
• GIMP 2.6インストールフォルダ\lib\gimp\2.0\interpreters\pygimp.interp で、Python 2.6への正しいパスが指定されていること。
• GIMP 2.6インストールフォルダ\lib\gimp\2.0\plug-ins\ 内の *.py で /usr/bin/env が記述されていないこと。

python=C:\Python\Python26\pythonw.exe
/usr/bin/python=C:\Python\Python26\pythonw.exe
:Python:E::py::python:

@echo off
set GIMPPATH=D:\Prog\GIMP-2.6.12\GIMP-2.0
set PYPATH=C:\Python\Python26

set GTKPATH=%PYPATH%\Lib\site-packages\gtk-2.0\runtime\bin
set GIMPFUPATH=%GIMPPATH%\lib\gimp\2.0\python

set PATH=%PYPATH%;%PYPATH%\Scripts;%GTKPATH%;%GIMPPATH%\bin;%PATH%
@rem set PATH=%PYPATH%;%PYPATH%\Scripts;%GIMPPATH%\bin;%PATH%

@rem set PYTHONPATH=%PYPATH%\Lib\site-packages
set PYTHONPATH=%GIMPFUPATH%
set PYTHON_ROOT=%PYPATH%

echo.
echo add path %PYPATH%
echo add path %PYPATH%\Scripts
echo add path %GTKPATH%
echo add path %GIMPPATH%\bin
echo.
echo PYTHONPATH=%PYTHONPATH%
echo PYTHON_ROOT=%PYTHON_ROOT%

@rem cd /d %GIMPPATH%
@rem cd /d %GIMPPATH%\bin
cd /d %USERPROFILE%
%GIMPPATH%\bin\gimp-2.6.exe %1 %2 %3 %4 %5 %6 %7 %8 %9

• include\ を、MinGWインストールフォルダ\include\ にコピー。
• lib-mingw\*.a を、MinGWインストールフォルダ\lib\ にコピー。
• lib-mingw\*.dll を、MinGWインストールフォルダ\bin\ にコピー。

#include <GLFW/glfw3.h>

int main(void)
{
  GLFWwindow* window;

  /* Initialize the library */
  if (!glfwInit())
    return -1;

  /* Create a windowed mode window and its OpenGL context */
  window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
  if (!window)
    {
      glfwTerminate();
      return -1;
    }

  /* Make the window's context current */
  glfwMakeContextCurrent(window);

  /* Loop until the user closes the window */
  while (!glfwWindowShouldClose(window))
    {
      /* Render here */
      glClear(GL_COLOR_BUFFER_BIT);

      /* Swap front and back buffers */
      glfwSwapBuffers(window);

      /* Poll for and process events */
      glfwPollEvents();
    }

  glfwTerminate();
  return 0;
}

gcc 01_hello_glfw.c -o 01_hello_glfw.exe -static -lglfw3 -lopengl32 -lwinmm -lgdi32 -mwindows

pacman -S mingw-w64-x86_64-glfw mingw-w64-x86_64-glew 
pacman -S mingw-w64-i686-glfw mingw-w64-i686-glew

import sys
import math
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *

# SCRW, SCRH = 1280, 720
SCRW, SCRH = 512, 288
FPS = 60

ang = 0.0
window = 0


def draw_func():
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    
    # set light
    glDisable(GL_LIGHTING)
    glEnable(GL_LIGHTING)
    glEnable(GL_NORMALIZE)
    glLightfv(GL_LIGHT0, GL_POSITION, [0.25, 1.0, 0.5, 0])
    glLightfv(GL_LIGHT0, GL_DIFFUSE, [1, 1, 1, 1])
    glLightfv(GL_LIGHT0, GL_SPECULAR, [1, 1, 1, 1])
    glEnable(GL_LIGHT0)

    glLoadIdentity()
    
    # rotate camera position
    r = 30
    x = r * math.cos(math.radians(ang))
    y = r * 0.5
    z = r * math.sin(math.radians(ang))
    tx, ty, tz = 0, 0, 0
    gluLookAt(x, y, z, tx, ty, tz, 0, 1, 0)

    glScalef(1.0, 1.0, 1.0)

    # set color
    green = [0.0, 1.0, 0.0, 1.0]
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, green)

    # draw sphere
    quadric = gluNewQuadric()
    # radius = 0.25 * math.sin(math.radians(ang * 8)) + 1.0
    radius = 4 * math.sin(math.radians(ang * 8)) + 5.0
    slices = 32
    stacks = 16
    gluSphere(quadric, radius, slices, stacks)
        
    glDisable(GL_LIGHT0)
    glDisable(GL_LIGHTING)
    
    # set color
    c = 0.5 * math.cos(math.radians(ang * 2)) + 0.5
    glColor3f(0.0, c, 1.0 - c)
    # glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, [0.0, 1.0, 1.0, 1.0])

    # draw cube
    glutWireCube(20)

    glutSwapBuffers()


def init_GL():
    global window

    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH)
    # glutInitWindowPosition(0, 0)
    glutInitWindowSize(SCRW, SCRH)
    window = glutCreateWindow("Draw sphere")

    glClearColor(0.0, 0.0, 0.0, 0.0)
    glClearDepth(1.0)

    glDepthFunc(GL_LESS)
    glEnable(GL_DEPTH_TEST)

    glShadeModel(GL_SMOOTH)
    # glShadeModel(GL_FLAT)

    glDisable(GL_LIGHTING)
    glEnable(GL_LIGHTING)
    glEnable(GL_NORMALIZE)

    # glEnable(GL_CULL_FACE)
    # glCullFace(GL_BACK)

    glViewport(0, 0, SCRW, SCRH)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(45, float(SCRW) / float(SCRH), 0.1, 100.0)

    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()


def on_timer(value):
    global ang
    ang += 0.5
    glutPostRedisplay()
    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def key_func(key, x, y):
    global window

    ESCAPE = b"\x1b"
    print("Push key,", key, x, y)
    if key == ESCAPE or key == b"q":
        print("Exit")
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()


def main():
    # main
    init_GL()
    glutKeyboardFunc(key_func)
    glutDisplayFunc(draw_func)
    glutTimerFunc(int(1000 / FPS), on_timer, 0)
    glutMainLoop()


if __name__ == "__main__":
    main()

>>> import time
>>> time.time()
1663505711.946
>>> time.time()
1663505714.521

>>> import time
>>> time.time()
1663505644.9368925
>>> time.time()
1663505648.3456943

• 画面左下が (0, 0) になっている。
• OpenGL 1.4 から追加されたメソッドなので、OpenGL 1.1 等では使えない。

gcc 01_gl_bound_ball.c -o 01_gl_bound_ball.exe -static -D FREEGLUT_STATIC -lfreeglut_static -lopengl32 -lglu32 -lwinmm -lgdi32 -mwindows

• Windowsが64bit版、スクリーンセーバが32bit版なら、C:\Windows\SysWOW64\ 以下にコピー。
• Windowsが64bit版、スクリーンセーバが64bit版なら、C:\Windows\System32\ 以下にコピー。
• Windowsが32bit版なら、C:\Windows\System32\ 以下にコピー。

• 箱の一辺の長さが目標FPSで、赤い線の長さが実際のFPS。
• 例えば、赤い線の長さが、箱の一辺の0.95程度の長さなら、63 * 0.95 ≒ 60FPS が実際のFPS、ということになる。

Windows OSのシステムクロックは15.6ミリ秒の分解能しかもたないため（Windows 7）、記載のような事象が発生します。

この動作の原因は、Windows XP のハードウェア アブストラクションレイヤ モジュール:HAL.DLL の仕様の違いによるものであり、そのPCが使用しているHALの種類によってタイマ精度が決まります。

タイマ精度 約 10mS となるマシンは halacpi.dll が使用されており、タイマ精度 16mS となるマシンには halaacpi.dll が使用されております。

最近の機種では、割り込みコントローラに APIC (Advanced PIC) を 使用しておりまして、この場合、HAL は halaacpi.dll が使用されます。

タイマの精度 - お仕事メモ帳 より

import sys
import math
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
from PIL import Image

IMG_NAME = "img_rgba.png"

SCRW, SCRH = 512, 512
FPS = 60

scr_w, scr_h = SCRW, SCRH
window = 0

# Rotation angle for the Quads
rotx = 0.0
roty = 0.0

texture = 0


def load_texture():
    global texture

    # load image by using PIL
    im = Image.open(IMG_NAME)
    w, h = im.size
    print("Image: %d x %d, %s" % (w, h, im.mode))

    if im.mode == "RGB":
        # RGB convert to RGBA
        im.putalpha(alpha=255)
    elif im.mode == "L" or im.mode == "P":
        # Grayscale, Index Color convert to RGBA
        im = im.convert("RGBA")

    raw_image = im.tobytes()

    ttype = GL_RGBA
    if im.mode == "RGB":
        ttype = GL_RGB
        print("Set GL_RGB")
    elif im.mode == "RGBA":
        ttype = GL_RGBA
        print("Set GL_RGBA")

    glBindTexture(GL_TEXTURE_2D, glGenTextures(1))

    # glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4)

    # set texture
    glTexImage2D(
        GL_TEXTURE_2D,      # target
        0,                  # MIPMAP level
        ttype,              # texture type (RGB, RGBA)
        w,                  # texture image width
        h,                  # texture image height
        0,                  # border width
        ttype,              # texture type (RGB, RGBA)
        GL_UNSIGNED_BYTE,   # data is unsigne char
        raw_image,          # texture data pointer
    )

    glClearColor(0, 0, 0, 0)
    glShadeModel(GL_SMOOTH)

    # set texture repeat
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)

    # set texture filter
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)


def set_billboard_matrix():
    m = glGetDoublev(GL_MODELVIEW_MATRIX)
    m[0][0] = m[1][1] = m[2][2] = 1.0
    m[0][1] = m[0][2] = 0.0
    m[1][0] = m[1][2] = 0.0
    m[2][0] = m[2][1] = 0.0
    glLoadMatrixd(m)


def draw_gl():
    global rotx, roty

    glClearColor(0.125, 0.25, 0.5, 0.0)  # background color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    glLoadIdentity()  # Reset The View

    # move camera
    r = 12.0
    ex = r * math.cos(math.radians(roty + 90.0))
    ey = 5.0
    ez = r * math.sin(math.radians(roty + 90.0))
    tx, ty, tz = 0.0, 0.0, 0.0
    gluLookAt(ex, ey, ez, tx, ty, tz, 0, 1, 0)

    glEnable(GL_BLEND)
    glEnable(GL_TEXTURE_2D)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    glColor4f(1.0, 1.0, 1.0, 1.0)  # color

    # draw floor quads
    glPushMatrix()

    w = 5.0
    glBegin(GL_QUADS)

    glTexCoord2f(0.0, 0.0)  # set u, v
    glVertex3f(-w, 0.0, -w)  # Top Left

    glTexCoord2f(1.0, 0.0)
    glVertex3f(w, 0.0, -w)  # Top Right

    glTexCoord2f(1.0, 1.0)
    glVertex3f(w, 0.0, w)  # Bottom Right

    glTexCoord2f(0.0, 1.0)
    glVertex3f(-w, 0.0, w)  # Bottom Left

    glEnd()
    glPopMatrix()

    # draw object quads
    for i in range(0, 300, 20):
        x = 5.0 * math.cos(math.radians(i))
        y = 0.0
        z = 5.0 * math.sin(math.radians(i))

        glPushMatrix()
        glTranslatef(x, y, z)  # translate

        set_billboard_matrix()

        glBegin(GL_QUADS)

        glTexCoord2f(0.0, 0.0)  # set u, v
        glVertex3f(-1.0, 2.0, 0)  # Top Left

        glTexCoord2f(1.0, 0.0)
        glVertex3f(1.0, 2.0, 0.0)  # Top Right

        glTexCoord2f(1.0, 1.0)
        glVertex3f(1.0, 0.0, 0.0)  # Bottom Right

        glTexCoord2f(0.0, 1.0)
        glVertex3f(-1.0, 0.0, 0.0)  # Bottom Left

        glEnd()
        glPopMatrix()

    glDisable(GL_TEXTURE_2D)

    glutSwapBuffers()


def init_viewport_and_pers(width, height):
    # Prevent A Divide By Zero If The Window Is Too Small
    if height == 0:
        height = 1

    scr_w, scr_h = width, height

    # Reset The Current Viewport And Perspective Transformation
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()  # Reset The Projection Matrix

    # Calculate The Aspect Ratio Of The Window
    # gluPerspective(fovy, aspect, zNear, zFar )
    gluPerspective(60.0, float(width) / float(height), 0.1, 100.0)
    glMatrixMode(GL_MODELVIEW)


def InitGL(width, height):
    glClearColor(0.125, 0.25, 0.5, 0.0)  # background color
    glClearDepth(1.0)  # Enables Clearing Of The Depth Buffer
    glEnable(GL_DEPTH_TEST)  # Enables Depth Testing
    glDepthFunc(GL_LESS)  # The Type Of Depth Test To Do
    glShadeModel(GL_SMOOTH)  # Enables Smooth Color Shading

    init_viewport_and_pers(width, height)


def resize_gl(width, height):
    init_viewport_and_pers(width, height)


def on_timer(value):
    global rotx, roty
    rotx = 0.0
    roty = roty + 0.5
    glutPostRedisplay()
    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def key_pressed(key, x, y):
    # If escape is pressed, kill everything.
    ESCAPE = b"\x1b"
    if key == ESCAPE or key == b'q':
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()


def main():
    global window

    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(SCRW, SCRH)
    # glutInitWindowPosition(0, 0)

    window = glutCreateWindow(b"Draw texture")

    glutDisplayFunc(draw_gl)
    glutReshapeFunc(resize_gl)
    glutKeyboardFunc(key_pressed)
    # glutFullScreen()

    # glutIdleFunc(draw_gl)
    glutTimerFunc(int(1000 / FPS), on_timer, 0)

    InitGL(SCRW, SCRH)

    load_texture()

    glutMainLoop()


if __name__ == "__main__":
    print("Hit ESC key to quit.")
    main()

def set_billboard_matrix():
    m = glGetDoublev(GL_MODELVIEW_MATRIX)
    m[0][0] = m[1][1] = m[2][2] = 1.0
    m[0][1] = m[0][2] = 0.0
    m[1][0] = m[1][2] = 0.0
    m[2][0] = m[2][1] = 0.0
    glLoadMatrixd(m)

m[0][0]  m[1][0]  m[2][0]  m[3][0]
m[0][1]  m[1][1]  m[2][1]  m[3][1]
m[0][2]  m[1][2]  m[2][2]  m[3][2]
m[0][3]  m[1][3]  m[2][3]  m[3][3]

    glDepthMask(GL_FALSE)
    glDepthFunc(GL_LEQUAL)

    # draw billboard ...

    glDepthMask(GL_TRUE)
    glDepthFunc(GL_LESS)

    glAlphaFunc(GL_GREATER, 0.5)
    glEnable(GL_ALPHA_TEST)

    # draw billboard ...

    glDisable(GL_ALPHA_TEST)

• glEnable(GL_ALPHA_TEST) や glDisable(GL_ALPHA_TEST) は、alpha test という処理を有効化/無効化している。
• glAlphaFunc(GL_GREATER, 0.5) は、アルファチャンネルのしきい値を設定している。

    if USE_DEPTHMASK:
        glDepthMask(GL_TRUE)
        glDepthFunc(GL_LESS)
    else:
        glDepthMask(GL_FALSE)
        glDepthFunc(GL_LEQUAL)

    # record position
    pos = []
    for i in range(0, 300, 20):
        x = 5.0 * math.cos(math.radians(i))
        y = 0.0
        z = 5.0 * math.sin(math.radians(i))

        if GET_DISTANCE:
            # get distance from camera to billboard
            dx = x - cam_pos[0]
            dy = y - cam_pos[1]
            dz = z - cam_pos[2]
            dist = dx * dx + dy * dy + dz * dz
            pos.append([x, y, z, dist])
        else:
            # get z value
            glPushMatrix()
            glTranslatef(x, y, z)  # translate
            
            m = glGetDoublev(GL_MODELVIEW_MATRIX)
            tx, ty, tz = m[3][0], m[3][1], m[3][2]
            
            pos.append([x, y, z, tz])
            glPopMatrix()

    # sort billboard
    s_pos = sorted(pos, key=lambda x: x[3])
    
    if GET_DISTANCE:
        s_pos.reverse()

    for p in s_pos:
        x, y, z, _ = p
        
        # draw billboard

import sys
import math
import random
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
from PIL import Image

IMG_NAME = "tex.png"

# SCRW, SCRH = 1600, 900
SCRW, SCRH = 512, 512
FPS = 60

FLOOR_W = 10.0
TREES_MAX = 256

# USE_DEPTHMASK = True
USE_DEPTHMASK = False

# GET_DISTANCE = True
GET_DISTANCE = False

scr_w, scr_h = SCRW, SCRH
window = 0

# Rotation angle for the Quads
rotx = 0.0
roty = 0.0

objs = []

texture = 0

# lighting
light_ambient = [1.0, 1.0, 1.0, 1.0]
light_diffuse = [1.0, 1.0, 1.0, 1.0]
light_specular = [1.0, 1.0, 1.0, 1.0]
light_position = [5.0, 5.0, 10.0, 1.0]

# material
no_mat = [0.0, 0.0, 0.0, 1.0]
mat_ambient = [0.05, 0.1, 0.25, 1.0]
mat_diffuse = [0.0, 1.0, 0.0, 1.0]
mat_specular = [0.5, 0.5, 0.5, 1.0]
mat_emission = [0.2, 0.2, 0.2, 0.0]
no_shininess = [0.0]
low_shininess = [5.0]
high_shininess = [100.0]


class Obj:

    def __init__(self, x, y, z, scale, kind):
        self.x = x
        self.y = y
        self.z = z
        self.scale = scale

        uv = [
            (0.5, 0.0), (0.75, 0.0), (0.5, 0.25), (0.75, 0.25),
            (0.5, 0.5), (0.75, 0.5), (0.5, 0.75), (0.75, 0.75),
        ]
        self.u, self.v = uv[kind]

    def draw(self):
        glAlphaFunc(GL_GREATER, 0.5)
        glEnable(GL_ALPHA_TEST)

        glEnable(GL_BLEND)
        glEnable(GL_TEXTURE_2D)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
        glDisable(GL_LIGHTING)

        glColor4f(1.0, 1.0, 1.0, 1.0)  # color

        glPushMatrix()
        glTranslatef(self.x, self.y, self.z)  # translate

        m = glGetDoublev(GL_MODELVIEW_MATRIX)
        m[0][0] = m[1][1] = m[2][2] = 1.0
        m[0][1] = m[0][2] = 0.0
        m[1][0] = m[1][2] = 0.0
        m[2][0] = m[2][1] = 0.0
        glLoadMatrixd(m)

        w = 1.0 * self.scale
        u, v = self.u, self.v
        uw = 0.25

        glBegin(GL_QUADS)

        glTexCoord2f(u, v)
        glVertex3f(-w, w * 2, 0)  # Top Left

        glTexCoord2f(u + uw, v)
        glVertex3f(w, w * 2, 0.0)  # Top Right

        glTexCoord2f(u + uw, v + uw)
        glVertex3f(w, 0.0, 0.0)  # Bottom Right

        glTexCoord2f(u, v + uw)
        glVertex3f(-w, 0.0, 0.0)  # Bottom Left

        glEnd()
        glPopMatrix()

        glDisable(GL_ALPHA_TEST)
        glDisable(GL_TEXTURE_2D)


def init_objs():
    global objs
    w = FLOOR_W
    n = 4.0
    kind = 0
    i = 0
    while i < TREES_MAX:
        x = random.uniform(-w, w)
        y = 0
        z = random.uniform(-w, w)
        if (x * x + z * z <= n * n):
            continue

        scale = random.uniform(1.0, 1.5)
        objs.append(Obj(x, y, z, scale, kind))
        kind = (kind + 1) % 4
        i += 1


def draw_objs():
    global objs
    for obj in objs:
        obj.draw()


def load_texture():
    global texture

    # load image by using PIL
    im = Image.open(IMG_NAME)
    w, h = im.size
    print("Image: %d x %d, %s" % (w, h, im.mode))

    if im.mode == "RGB":
        # RGB convert to RGBA
        im.putalpha(alpha=255)
    elif im.mode == "L" or im.mode == "P":
        # Grayscale, Index Color convert to RGBA
        im = im.convert("RGBA")

    raw_image = im.tobytes()

    ttype = GL_RGBA
    if im.mode == "RGB":
        ttype = GL_RGB
        print("Set GL_RGB")
    elif im.mode == "RGBA":
        ttype = GL_RGBA
        print("Set GL_RGBA")

    glBindTexture(GL_TEXTURE_2D, glGenTextures(1))

    # glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4)

    # set texture
    glTexImage2D(
        GL_TEXTURE_2D,      # target
        0,                  # MIPMAP level
        ttype,              # texture type (RGB, RGBA)
        w,                  # texture image width
        h,                  # texture image height
        0,                  # border width
        ttype,              # texture type (RGB, RGBA)
        GL_UNSIGNED_BYTE,   # data is unsigne char
        raw_image,          # texture data pointer
    )

    glClearColor(0, 0, 0, 0)
    glShadeModel(GL_SMOOTH)

    # set texture repeat
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)

    # set texture filter
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)


def draw_floor():
    """Draw floor quads."""

    w = FLOOR_W
    u, v = 0.0, 0.0
    uw = 0.5

    glDisable(GL_LIGHTING)

    glEnable(GL_BLEND)
    glEnable(GL_TEXTURE_2D)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    glColor4f(1.0, 1.0, 1.0, 1.0)  # color

    glPushMatrix()

    glBegin(GL_QUADS)

    glTexCoord2f(u, v)
    glVertex3f(-w, 0.0, -w)  # Top Left

    glTexCoord2f(u + uw, v)
    glVertex3f(w, 0.0, -w)   # Top Right

    glTexCoord2f(u + uw, v + uw)
    glVertex3f(w, 0.0, w)    # Bottom Right

    glTexCoord2f(u, v + uw)
    glVertex3f(-w, 0.0, w)   # Bottom Left

    glEnd()
    glPopMatrix()


def draw_cube():
    """ Draw cube."""
    glEnable(GL_LIGHTING)
    glEnable(GL_LIGHT0)

    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse)
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular)
    glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess)
    glMaterialfv(GL_FRONT, GL_EMISSION, no_mat)

    glPushMatrix()
    glDisable(GL_TEXTURE_2D)
    glColor3f(0.0, 1.0, 0.0)

    if False:
        glTranslatef(0.0, 2.0, 0.0)
        glutSolidCube(4.0)
    else:
        glTranslatef(0.0, 1.2, 0.0)
        glutSolidTeapot(2.0)

    glPopMatrix()


def draw_gl():
    global rotx, roty

    glClearColor(0.85, 0.85, 0.85, 0.0)  # background color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    # set light
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient)
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse)
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular)
    glLightfv(GL_LIGHT0, GL_POSITION, light_position)
    glEnable(GL_LIGHTING)
    glEnable(GL_LIGHT0)

    glLoadIdentity()  # Reset The View

    # move camera
    r = 16.0
    ex = r * math.cos(math.radians(roty + 90.0))
    ey = 6.0 + 4.0 * math.cos(math.radians(roty * 3))
    ez = r * math.sin(math.radians(roty + 90.0))
    tx, ty, tz = 0.0, 0.0, 0.0
    gluLookAt(ex, ey, ez, tx, ty, tz, 0, 1, 0)
    cam_pos = (ex, ey, ez)

    draw_floor()

    draw_cube()

    draw_objs()

    glutSwapBuffers()


def init_viewport_and_pers(width, height):
    # Prevent A Divide By Zero If The Window Is Too Small
    if height == 0:
        height = 1

    scr_w, scr_h = width, height

    # Reset The Current Viewport And Perspective Transformation
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()  # Reset The Projection Matrix

    # Calculate The Aspect Ratio Of The Window
    # gluPerspective(fovy, aspect, zNear, zFar )
    gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
    glMatrixMode(GL_MODELVIEW)


def InitGL(width, height):
    glClearColor(0.85, 0.85, 0.85, 0.0)  # background color
    glClearDepth(1.0)  # Enables Clearing Of The Depth Buffer
    glEnable(GL_DEPTH_TEST)  # Enables Depth Testing
    glDepthFunc(GL_LESS)  # The Type Of Depth Test To Do
    glShadeModel(GL_SMOOTH)  # Enables Smooth Color Shading

    # setiing fog
    fog_color = [0.85, 0.85, 0.85]
    glEnable(GL_FOG)
    glFogi(GL_FOG_MODE, GL_LINEAR)
    glFogfv(GL_FOG_COLOR, fog_color)
    glFogf(GL_FOG_DENSITY, 0.1)
    glHint(GL_FOG_HINT, GL_DONT_CARE)
    glFogf(GL_FOG_START, 8.0)
    glFogf(GL_FOG_END, 25.0)

    init_viewport_and_pers(width, height)


def resize_gl(width, height):
    init_viewport_and_pers(width, height)


def on_timer(value):
    global rotx, roty
    rotx = 0.0
    roty = roty + 0.25
    glutPostRedisplay()
    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def key_pressed(key, x, y):
    # If escape is pressed, kill everything.
    ESCAPE = b"\x1b"
    if key == ESCAPE or key == b'q':
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()


def main():
    global window

    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(SCRW, SCRH)
    # glutInitWindowPosition(0, 0)

    window = glutCreateWindow(b"Draw texture")

    glutDisplayFunc(draw_gl)
    glutReshapeFunc(resize_gl)
    glutKeyboardFunc(key_pressed)
    # glutFullScreen()

    # glutIdleFunc(draw_gl)
    glutTimerFunc(int(1000 / FPS), on_timer, 0)

    InitGL(SCRW, SCRH)

    load_texture()

    init_objs()

    glutMainLoop()


if __name__ == "__main__":
    print("Hit ESC key to quit.")
    main()

    # setiing fog
    fog_color = [0.85, 0.85, 0.85]
    glEnable(GL_FOG)
    glFogi(GL_FOG_MODE, GL_LINEAR)
    glFogfv(GL_FOG_COLOR, fog_color)
    glFogf(GL_FOG_DENSITY, 0.1)
    glHint(GL_FOG_HINT, GL_DONT_CARE)
    glFogf(GL_FOG_START, 8.0)
    glFogf(GL_FOG_END, 25.0)

• glEnable(GL_FOG)、glDisable(GL_FOG) で、フォグの有効/無効を切り替えられる。
• fog_color がフォグの色。[1.0, 1.0, 1.0] なら真っ白になるし、[0.0, 0.0, 0.0] なら真っ黒になる。
• glFogfv(GL_FOG_COLOR, fog_color) で、フォグの色を指定している。
• glFogi(GL_FOG_MODE, GL_LINEAR) で、フォグのかかり方の種類を指定している。
• フォグのかかり方が GL_LINEAR の場合、GL_FOG_START、GL_FOG_END で、フォグがかかり始める距離を指定できるらしい。
• GL_FOG_DENSITY の値は、フォグのかかり方 (GL_FOG_MODE) が、GL_EXP、GL_EXP2 の場合に絡んでくるらしい。今回は GL_LINEAR にしているから、関係してこないっぽい。