OSX上C OpenGL程序的基本框架

在OSX上用C在OpenGL窗口中绘制三角形的裸骨架是什么？我已经阅读了Nehe的教程，并试图让它工作，但CreateGLWindow似乎与win32毫无希望地捆绑在一起

我只想坚持使用opengl和glut，等等。我最终将在scheme中对此进行包装，但我希望事先在c级有一个更坚定的理解

到目前为止，我所掌握的情况如下：

#include <OpenGL/gl.h>// Header File For The OpenGL32 Library
#include <OpenGL/glu.h>// Header File For The GLu32 Library
#include <GLUT/glut.h>// Header File For The GLut Library

#define kWindowWidth 400;
#define kWindowHeight 300;

HGLRC hRC=NULL;// Permanent Rendering Context
HDC             hDC=NULL;// Private GDI Device Context
HWND            hWnd=NULL;// Holds Our Window Handle
HINSTANCE       hInstance;// Holds The Instance Of The Application

LRESULTCALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);// Declaration For WndProc

boolkeys[256];// Array Used For The Keyboard Routine
boolactive=TRUE;// Window Active Flag Set To TRUE By Default
boolfullscreen=TRUE;// Fullscreen Flag Set To Fullscreen Mode By Default

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)// Resize And Initialize The GL Window
{
  if (height==0)// Prevent A Divide By Zero By
    {
      height=1;// Making Height Equal One
    }

  glViewport(0, 0, width, height);// Reset The Current Viewport
  glMatrixMode(GL_PROJECTION);// Select The Projection Matrix
  glLoadIdentity();// Reset The Projection Matrix

  // Calculate The Aspect Ratio Of The Window
  gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

  glMatrixMode(GL_MODELVIEW);// Select The Modelview Matrix
  glLoadIdentity();// Reset The Modelview Matrix
}

int InitGL(GLvoid)// All Setup For OpenGL Goes Here
{
  glShadeModel(GL_SMOOTH);// Enables Smooth Shading
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);// Black Background
  glClearDepth(1.0f);// Depth Buffer Setup
  glEnable(GL_DEPTH_TEST);// Enables Depth Testing
  glDepthFunc(GL_LEQUAL);// The Type Of Depth Test To Do
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);// Really Nice Perspective Calculations

  return TRUE;// Initialization Went OK
}

int DrawGLScene(GLvoid)// Here's Where We Do All The Drawing
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);// Clear The Screen And The Depth Buffer
  glLoadIdentity();// Reset The Current Modelview Matrix
  return TRUE;// Everything Went OK
}

GLvoid KillGLWindow(GLvoid)// Properly Kill The Window
{
  if (fullscreen)// Are We In Fullscreen Mode?
    {
      ChangeDisplaySettings(NULL,0);// If So Switch Back To The Desktop
      ShowCursor(TRUE);// Show Mouse Pointer
    }

  if (hRC)// Do We Have A Rendering Context?
    {
      if (!wglMakeCurrent(NULL,NULL))// Are We Able To Release The DC And RC Contexts?
        {
          MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }
      if (!wglDeleteContext(hRC))// Are We Able To Delete The RC?
        {
          MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }
      hRC=NULL;// Set RC To NULL
    }
  if (hDC && !ReleaseDC(hWnd,hDC))// Are We Able To Release The DC
    {
      MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      hDC=NULL;// Set DC To NULL
    }

  if (hWnd && !DestroyWindow(hWnd))// Are We Able To Destroy The Window?
    {
      MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      hWnd=NULL;// Set hWnd To NULL
    }

  if (!UnregisterClass("OpenGL",hInstance))// Are We Able To Unregister Class
    {
      MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      hInstance=NULL;// Set hInstance To NULL
    }
}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
  GLuintPixelFormat;// Holds The Results After Searching For A Match
  WNDCLASSwc;// Windows Class Structure

  DWORDdwExStyle;// Window Extended Style
  DWORDdwStyle;// Window Style

  RECT WindowRect;// Grabs Rectangle Upper Left / Lower Right Values
  WindowRect.left=(long)0;// Set Left Value To 0
  WindowRect.right=(long)width;// Set Right Value To Requested Width
  WindowRect.top=(long)0;// Set Top Value To 0
  WindowRect.bottom=(long)height;// Set Bottom Value To Requested Height

  fullscreen=fullscreenflag;// Set The Global Fullscreen Flag

  hInstance= GetModuleHandle(NULL);// Grab An Instance For Our Window
  wc.style= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;// Redraw On Move, And Own DC For Window
  wc.lpfnWndProc= (WNDPROC) WndProc;// WndProc Handles Messages
  wc.cbClsExtra= 0;// No Extra Window Data
  wc.cbWndExtra= 0;// No Extra Window Data
  wc.hInstance= hInstance;// Set The Instance
  wc.hIcon= LoadIcon(NULL, IDI_WINLOGO);// Load The Default Icon
  wc.hCursor= LoadCursor(NULL, IDC_ARROW);// Load The Arrow Pointer
  wc.hbrBackground= NULL;// No Background Required For GL
  wc.lpszMenuName= NULL;// We Don't Want A Menu
  wc.lpszClassName= "OpenGL";// Set The Class Name

  if (!RegisterClass(&wc))// Attempt To Register The Window Class
    {
      MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Exit And Return FALSE
    }

  if (fullscreen)// Attempt Fullscreen Mode?
    {
      DEVMODE dmScreenSettings;// Device Mode
      memset(&dmScreenSettings,0,sizeof(dmScreenSettings));// Makes Sure Memory's Cleared
      dmScreenSettings.dmSize=sizeof(dmScreenSettings);// Size Of The Devmode Structure
      dmScreenSettings.dmPelsWidth= width;// Selected Screen Width
      dmScreenSettings.dmPelsHeight= height;// Selected Screen Height
      dmScreenSettings.dmBitsPerPel= bits;// Selected Bits Per Pixel
      dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

      // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
      if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
        {
          // If The Mode Fails, Offer Two Options.  Quit Or Run In A Window.
          if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
            {
              fullscreen=FALSE;// Select Windowed Mode (Fullscreen=FALSE)
            }
          else
            {
              // Pop Up A Message Box Letting User Know The Program Is Closing.
              MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
              return FALSE;// Exit And Return FALSE
            }
        }
    }

  if (fullscreen)// Are We Still In Fullscreen Mode?
    {
      dwExStyle=WS_EX_APPWINDOW;// Window Extended Style
      dwStyle=WS_POPUP;// Windows Style
      ShowCursor(FALSE);// Hide Mouse Pointer
    }
  else
    {
      dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;// Window Extended Style
      dwStyle=WS_OVERLAPPEDWINDOW;// Windows Style
    }

  AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);// Adjust Window To True Requested Size

  if (!(hWnd=CreateWindowEx(dwExStyle,// Extended Style For The Window
                            "OpenGL",// Class Name
                            title,// Window Title
                            WS_CLIPSIBLINGS |// Required Window Style
                            WS_CLIPCHILDREN |// Required Window Style
                            dwStyle,// Selected Window Style
                            0, 0,// Window Position
                            WindowRect.right-WindowRect.left,// Calculate Adjusted Window Width
                            WindowRect.bottom-WindowRect.top,// Calculate Adjusted Window Height
                            NULL,// No Parent Window
                            NULL,// No Menu
                            hInstance,// Instance
                            NULL)))// Don't Pass Anything To WM_CREATE
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }

  staticPIXELFORMATDESCRIPTOR pfd=// pfd Tells Windows How We Want Things To Be
    {
      sizeof(PIXELFORMATDESCRIPTOR),// Size Of This Pixel Format Descriptor
      1,// Version Number
      PFD_DRAW_TO_WINDOW |// Format Must Support Window
      PFD_SUPPORT_OPENGL |// Format Must Support OpenGL
      PFD_DOUBLEBUFFER,// Must Support Double Buffering
      PFD_TYPE_RGBA,// Request An RGBA Format
      bits,// Select Our Color Depth
      0, 0, 0, 0, 0, 0,// Color Bits Ignored
      0,// No Alpha Buffer
      0,// Shift Bit Ignored
      0,// No Accumulation Buffer
      0, 0, 0, 0,// Accumulation Bits Ignored
      16,// 16Bit Z-Buffer (Depth Buffer)
      0,// No Stencil Buffer
      0,// No Auxiliary Buffer
      PFD_MAIN_PLANE,// Main Drawing Layer
      0,// Reserved
      0, 0, 0// Layer Masks Ignored
    };

  if (!(hDC=GetDC(hWnd)))// Did We Get A Device Context?
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }

  if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))// Did Windows Find A Matching Pixel Format?
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }

  if(!SetPixelFormat(hDC,PixelFormat,&pfd))// Are We Able To Set The Pixel Format?
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }

  if (!(hRC=wglCreateContext(hDC)))// Are We Able To Get A Rendering Context?
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }

  if(!wglMakeCurrent(hDC,hRC))// Try To Activate The Rendering Context
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }

  ShowWindow(hWnd,SW_SHOW);// Show The Window
  SetForegroundWindow(hWnd);// Slightly Higher Priority
  SetFocus(hWnd);// Sets Keyboard Focus To The Window
  ReSizeGLScene(width, height);// Set Up Our Perspective GL Screen

  if (!InitGL())// Initialize Our Newly Created GL Window
    {
      KillGLWindow();// Reset The Display
      MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;// Return FALSE
    }
  return TRUE;// Success
}

LRESULT CALLBACK WndProc(HWNDhWnd,// Handle For This Window
                         UINTuMsg,// Message For This Window
                         WPARAMwParam,// Additional Message Information
                         LPARAMlParam)// Additional Message Information
{
  switch (uMsg)// Check For Windows Messages
    {
    case WM_ACTIVATE:// Watch For Window Activate Message
      {
        if (!HIWORD(wParam))// Check Minimization State
          {
            active=TRUE;// Program Is Active
          }
        else
          {
            active=FALSE;// Program Is No Longer Active
          }

        return 0;// Return To The Message Loop
      }
    case WM_SYSCOMMAND:// Intercept System Commands
      {
        switch (wParam)// Check System Calls
          {
          case SC_SCREENSAVE:// Screensaver Trying To Start?
          case SC_MONITORPOWER:// Monitor Trying To Enter Powersave?
            return 0;// Prevent From Happening
          }
        break;// Exit
      }
    case WM_CLOSE:// Did We Receive A Close Message?
      {
        PostQuitMessage(0);// Send A Quit Message
        return 0;// Jump Back
      }
    case WM_KEYDOWN:// Is A Key Being Held Down?
      {
        keys[wParam] = TRUE;// If So, Mark It As TRUE
        return 0;// Jump Back
      }
    case WM_KEYUP:// Has A Key Been Released?
      {
        keys[wParam] = FALSE;// If So, Mark It As FALSE
        return 0;// Jump Back
      }
    case WM_SIZE:// Resize The OpenGL Window
      {
        ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
        return 0;// Jump Back
      }
    }
  // Pass All Unhandled Messages To DefWindowProc
  return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

GLvoid InitGL(GLvoid);
GLvoid DrawGLScene(GLvoid);
GLvoid ReSizeGLScene(int Width, int Height);

int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize (kWindowWidth, kWindowHeight);
  glutInitWindowPosition (100, 100);
  glutCreateWindow (argv[0]);

  InitGL();

  glutDisplayFunc(DrawGLScene);
  glutReshapeFunc(ReSizeGLScene);

  glutMainLoop();

  return 0;
}

#包含//OpenGL32库的头文件
#包含//GLu32库的头文件
#包含//GLut库的头文件
#定义kWindowWidth 400；
#定义kWindowHeight 300；
HGLRC hRC=NULL；//永久渲染上下文
HDC HDC=NULL；//专用GDI设备上下文
HWND HWND=NULL；//握住我们的窗户把手
HINSTANCE HINSTANCE；//保存应用程序的实例
LRESULTCALLBACK WndProc（HWND、UINT、WPARAM、LPARAM）；//WndProc声明
乡巴佬[256]；//用于键盘例程的数组
boolactive=TRUE；//默认情况下，窗口活动标志设置为TRUE
boolfullscreen=TRUE；//全屏标志默认设置为全屏模式
GLvoid ReSizeGLScene（GLsizei width，GLsizei height）//调整和初始化GL窗口的大小
{
if（height==0）//防止被零除以
{
高度=1；//使高度等于1
}
glViewport（0，0，宽度，高度）；//重置当前视口
glMatrixMode（GL_投影）；//选择投影矩阵
glLoadIdentity（）；//重置投影矩阵
//计算窗口的纵横比
透视图（45.0f，（GLfloat）宽度/（GLfloat）高度，0.1f，100.0f）；
glMatrixMode（GL_MODELVIEW）；//选择MODELVIEW矩阵
glLoadIdentity（）；//重置Modelview矩阵
}
int InitGL（GLvoid）//OpenGL的所有设置都在这里
{
glShadeModel（GL_平滑）；//启用平滑着色
glClearColor（0.0f，0.0f，0.0f，0.0f）；//黑色背景
glClearDepth（1.0f）；//深度缓冲区设置
glEnable（GL_DEPTH_TEST）；//启用深度测试
glDepthFunc（GL_LEQUAL）；//要执行的深度测试类型
glHint（GL_PERSPECTIVE_CORRECTION_HINT，GL_NICEST）；//非常好的透视计算
return TRUE；//初始化正常
}
int DrawGLScene（GLvoid）//这里是我们绘制所有图形的地方
{
glClear（GL_颜色_缓冲区| GL_深度_缓冲区|位）；//清除屏幕和深度缓冲区
glLoadIdentity（）；//重置当前模型视图矩阵
return TRUE；//一切正常
}
GLvoid KillGLWindow（GLvoid）//正确地关闭窗口
{
if（全屏）//我们是否处于全屏模式？
{
ChangeDisplaySettings（NULL，0）；//如果是，切换回桌面
ShowCursor（TRUE）；//显示鼠标指针
}
if（hRC）//我们有渲染上下文吗？
{
如果（！wglMakeCurrent（NULL，NULL））//我们能够释放DC和RC上下文吗？
{
消息框（NULL，“DC和RC释放失败”，“关机错误”，MB|U OK | MB|U图标信息）；
}
如果（！wglDeleteContext（hRC））//我们能够删除RC吗？
{
MessageBox（NULL，“发布呈现上下文失败”，“关闭错误”，MB|U OK | MB|U图标信息）；
}
hRC=NULL；//将RC设置为NULL
}
如果（hDC&！ReleaseDC（hWnd，hDC））//我们能够释放DC吗
{
消息框（NULL，“释放设备上下文失败”，“关机错误”，MB|U OK | MB|U图标信息）；
hDC=NULL；//将DC设置为NULL
}
如果（hWnd&！destronWindow（hWnd））//我们能够销毁窗口吗？
{
消息框（NULL，“无法释放hWnd.”，“关机错误”，MB|U OK | MB|U图标信息）；
hWnd=NULL；//将hWnd设置为NULL
}
如果（！UnregisterClass（“OpenGL”，hInstance））//我们可以注销类吗
{
MessageBox（NULL，“无法注销类”，“关机错误”，MB|U OK | MB|U图标信息）；
hInstance=NULL；//将hInstance设置为NULL
}
}
BOOL CreateGLWindow（字符*标题、整型宽度、整型高度、整型位、BOOL fullscreenflag）
{
GLuintPixelFormat；//在搜索匹配后保存结果
WNDCLASSwc；//Windows类结构
DWORDdwExStyle；//窗口扩展样式
DWORDdwStyle；//窗口样式
RECT WindowRect；//获取矩形的左上/右下值
WindowRect.left=（长）0；//将left值设置为0
WindowRect.right=（长）宽度；//将right值设置为请求的宽度
WindowRect.top=（长）0；//将top值设置为0
WindowRect.bottom=（长）高度；//将底部值设置为请求的高度
fullscreen=fullscreenflag；//设置全局全屏标志
hInstance=GetModuleHandle（NULL）；//为我们的窗口获取一个实例
wc.style=CS|HREDRAW | CS|u VREDRAW | CS|u OWNDC；//移动时重新绘制，并拥有窗口的DC
wc.lpfnWndProc=（WNDPROC）WNDPROC；//WNDPROC处理消息
wc.cbClsExtra=0；//没有额外的窗口数据
wc.cbWndExtra=0；//没有额外的窗口数据
wc.hInstance=hInstance；//设置实例
wc.hIcon=LoadIcon（NULL，IDI_WINLOGO）；//加载默认图标
wc.hCursor=LoadCursor（NULL，IDC_箭头）；//加载箭头指针
wc.hbrBackground=NULL；//总账不需要背景
wc.lpszMenuName=NULL；//我们不需要菜单
wc.lpszClassName=“OpenGL”；//设置类名
if（！RegisterClass（&wc））//尝试注册窗口类
{
MessageBox（NULL，“未能注册窗口类”，“错误”，MB|U OK | MB|U IConnexClation）；
return FALSE；//退出并返回FALSE
}
if（全屏）//是否尝试全屏模式？
{
DEVMODE dmScreenSettings；//设备模式
memset（&dmScreenSettings，0，sizeof（dmScreenSettings））；//确保已清除内存
dmScreenSettings.dmSize=sizeof（dmScreenSettings）；//Devmode结构的大小
dmScreenSettings.dmPelsWidth=width；//所选屏幕宽度
dmScreenSettings.dmPelsHeight=height；//所选屏幕高度
dmScreenSettings.dmBitsPerPel=位；//每像素选定位
dmScreenSettings.dmFields=DM|u BITSPERPEL | DM|u PELSWIDTH | DM|PELSHEIGHT；
//尝试设置所选模式并获得结果。注意：CDS\U全屏摆脱了开始栏。
如果（Ch
// The OpenGL libraries, make sure to include the GLUT and OpenGL frameworks
#include <GLUT/glut.h>
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>

// This is just an example using basic glut functionality.
// If you want specific Apple functionality, look up AGL

void init() // Called before main loop to set up the program
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);
}

// Called at the start of the program, after a glutPostRedisplay() and during idle
// to display a frame
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glBegin(GL_TRIANGLES);
        glVertex3f(0.0, 0.0, -10.0);
        glVertex3f(1.0, 0.0, -10.0);
        glVertex3f(0.0, 1.0, -10.0);
    glEnd();

    glutSwapBuffers();
}

// Called every time a window is resized to resize the projection matrix
void reshape(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-0.1, 0.1, -float(h)/(10.0*float(w)), float(h)/(10.0*float(w)), 0.5, 1000.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}


int main(int argc, char **argv)
{
    glutInit(&argc, argv); // Initializes glut

    // Sets up a double buffer with RGBA components and a depth component
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA);

    // Sets the window size to 512*512 square pixels
    glutInitWindowSize(512, 512);

    // Sets the window position to the upper left
    glutInitWindowPosition(0, 0);

    // Creates a window using internal glut functionality
    glutCreateWindow("Hello!");

    // passes reshape and display functions to the OpenGL machine for callback
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutIdleFunc(display);

    init();

    // Starts the program.
    glutMainLoop();
    return 0;
}