[很麻烦]opengl,step 0

shawind

2. //test.d
3. //save as utf 16 LE
4. //dmd test.d -L/exet:nt/su:windows:4.0
6. import win32.windows;
7. import std.c.string;
8. import opengl.gl;
10. pragma(lib,"win32.lib");
11. pragma(lib,"gdi32.lib");
12. pragma(lib,"opengl32.lib");
13. pragma(lib,"glu32.lib");
15. /*  Make the class name into a global variable  */
16. const wchar* szClassName = "OpenGL";
17. const wchar* szAppName = "OpenGL测试";
19. extern (C) void gc_init();
20. extern (C) void gc_term();
21. extern (C) void _minit();
22. extern (C) void _moduleCtor();
23. extern (C) void _moduleDtor();
24. extern (C) void _moduleUnitTests();
26. extern (Windows) int WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
27. {
28.     int result;
30.     gc_init();          // initialize garbage collector
31.     _minit();           // initialize module constructor table
33.     try
34.     {
35.         _moduleCtor();      // call module constructors
36.         _moduleUnitTests(); // run unit tests (optional)
38.         result = myWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
40.         _moduleDtor();      // call module destructors
41.     }
43.     catch (Object o)        // catch any uncaught exceptions
44.     {
45.         MessageBoxA(null, cast(char *)o.toString(), "Error",
46.                     MB_OK | MB_ICONEXCLAMATION);
47.         result = 0;     // failed
48.     }
50.     gc_term();          // run finalizers; terminate garbage collector
51.     return result;
52. }
54. int myWinMain (HINSTANCE hThisInstance,HINSTANCE hPrevInstance,LPSTR lpszArgument,int nFunsterStil)
55. {
56.     HWND hWnd;               /* This is the handle for our window */
57.     MSG messages;            /* Here messages to the application are saved */
58.     WNDCLASSEXW wincl;        /* Data structure for the windowclass */
59.     HDC hDC;
60.     HGLRC hRC;
61.     bool bQuit = false;
63.     /* The Window structure */
64.     wincl.hInstance = hThisInstance;
65.     wincl.lpszClassName = szClassName;
66.     wincl.lpfnWndProc = &WindowProcedure;      /* This function is called by windows */
67.     wincl.style = CS_OWNDC;                 /* Catch double-clicks */
68.     wincl.cbSize = WNDCLASSEXW.sizeof;
70.     /* Use default icon and mouse-pointer */
71.     wincl.hIcon = null;
72.     wincl.hIconSm = null;
73.     wincl.hCursor = null;
74.     wincl.lpszMenuName = null;                 /* No menu */
75.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
76.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
77.     /* Use Windows's default color as the background of the window */
78.     wincl.hbrBackground = cast(HBRUSH) COLOR_BACKGROUND;
80.     /* Register the window class, and if it fails quit the program */
81.     if (!RegisterClassExW (&wincl))
82.         return 0;
84.     /* The class is registered, let's create the program*/
85.     hWnd = CreateWindowExW (
86.                0,                   /* Extended possibilites for variation */
87.                szClassName,         /* Classname */
88.                szAppName,           /* Title Text */
89.                WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE, /* default window */
90.                CW_USEDEFAULT,       /* Windows decides the position */
91.                CW_USEDEFAULT,       /* where the window ends up on the screen */
92.                250,                 /* The programs width */
93.                250,                 /* and height in pixels */
94.                HWND_DESKTOP,        /* The window is a child-window to desktop */
95.                null,                /* No menu */
96.                hThisInstance,       /* Program Instance handler */
97.                null                 /* No Window Creation data */
98.            );
100.     /* enable OpenGL for the window */
101.     EnableOpenGL (hWnd, &hDC, &hRC);
103.     /* Make the window visible on the screen */
104.     ShowWindow (hWnd, nFunsterStil);
106.     while (!bQuit)
107.     {
108.         if (PeekMessage(&messages, null, 0, 0, PM_REMOVE))
109.         {
110.             if (messages.message == WM_QUIT)
111.             {
112.                 bQuit = true;
113.             }
114.             else
115.             {
116.                 /* Translate virtual-key messages into character messages */
117.                 TranslateMessage(&messages);
118.                 /* Send message to WindowProcedure */
119.                 DispatchMessageW(&messages);
120.             }
121.         }
122.         else
123.         {
124.             draw(hDC);
125.         }
128.     }
129.     /* shutdown OpenGL */
130.     DisableOpenGL (hWnd, hDC, hRC);
132.     /* destroy the window explicitly */
133.     DestroyWindow (hWnd);
135.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
136.     return messages.wParam;
137. }
139. /*  This function is called by the Windows function DispatchMessage()  */
140. extern(Windows) LRESULT WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
141. {
142.     switch (message)                  /* handle the messages */
143.     {
144.     case WM_DESTROY:
145.         PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
146.         break;
147.     default:                      /* for messages that we don't deal with */
148.         return DefWindowProcW (hwnd, message, wParam, lParam);
149.     }
151.     return 0;
152. }
154. void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
155. {
156.     PIXELFORMATDESCRIPTOR pfd;
157.     int iFormat;
159.     /* get the device context (DC) */
160.     *hDC = GetDC (hWnd);
162.     /* set the pixel format for the DC */
163.     memset(&pfd, pfd.sizeof,1);
164.     pfd.nSize = pfd.sizeof;
165.     pfd.nVersion = 1;
166.     pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
167.     pfd.iPixelType = PFD_TYPE_RGBA;
168.     pfd.cColorBits = 24;
169.     pfd.cDepthBits = 16;
170.     pfd.iLayerType = 0;
171.     //pfd.iLayerType = PFD_MAIN_PLANE;
172.     iFormat = ChoosePixelFormat (*hDC, &pfd);
173.     SetPixelFormat (*hDC, iFormat, &pfd);
175.     /* create and enable the render context (RC) */
176.     *hRC = wglCreateContext( *hDC );
177.     wglMakeCurrent( *hDC, *hRC );
178. }
181. void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
182. {
183.     wglMakeCurrent (null,null);
184.     wglDeleteContext (hRC);
185.     ReleaseDC (hWnd, hDC);
186. }
188. void draw(HDC hDC)
189. {
191.     glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
192.     glClear (GL_COLOR_BUFFER_BIT);
194.     glPushMatrix ();
195.     glRotatef (0.0f, 0.0f, 0.0f, 1.0f);
196.     glBegin (GL_TRIANGLES);
197.     glColor3f (1.0f, 0.0f, 0.0f);
198.     glVertex2f (0.0f, 1.0f);
199.     glColor3f (0.0f, 1.0f, 0.0f);
200.     glVertex2f (0.87f, -0.5f);
201.     glColor3f (0.0f, 0.0f, 1.0f);
202.     glVertex2f (-0.87f, -0.5f);
203.     glEnd ();
204.     glPopMatrix ();
206.     SwapBuffers (hDC);
208.     Sleep (1);
209. }

复制代码

lw

=0= 用D的……上次看到这个去下载了GDC来……
BUT就忘了编译……为什么不能够用C写……这样可以省力啊……

shawind

c的话，对于我个人来说有三个理由吧。
1.c的基本数据类看着别扭，unsign char ...不如直接ubyte多好。还有c不是强类型。
2.c里面没有委托可用。
3.c多线程的时候不是一般的麻烦。
而现在D的麻烦只是在库上，一旦越过了，后面就没有太麻烦的问题了。必竟D是号称能和ruby比开发效率，和c＋＋比运行效率的新语言嘛。虽然我对此没有任何体会。[s:5]

ps.如果是用c，我就直接去用irrlicht了，绝对不会多看dx＆opengl一眼。  [s:4]

lw

不解ING……
主要是用C可能比较适合偶看而已……，D今天看FX的那段闭包完全看不懂
如果光是函数里面嵌套函数也就罢了，什么delegate(int)……

之后又一堆东东，所以结果容易变成语法课了啊……

rednaxela

int delegate(int) ptr就是int (*ptr)(int)啊...这样容易明白些么?
在D有完全闭包前，它的delegate/function pointer很难说比C/C++的有多少改良...本来就是一回事。
不过在有完全闭包后，D里面的delegate就比C的要有更强的能力，在作为参数传递的时候也会传递更多信息。
……不过我觉得shawind应该没用到什么需要这种能力的地方……C里的函数指针估计是完全够用

shawind

是的，每个人的习惯不一样，喜爱的语言也不一样。

delegate(int)就是申明了一个委托类型。在c＃，d这类语言中，用委托比在c中只能使用函数指针要安全很多。
居说c＋＋的boost库里也实现了多线程和（委托？）之类的东西。但是上次尝试编译krkr2的时候，boost在我的心目里留下了很不友好的印像，所以一直都没有怎么接触。

shawind

因为我是用完全面向对像的思路来考虑实现引擎的。委托带有它周围的环境信息，在有很多类的时候，比较不容易指错地方。当然高手用c也能完成这种任务，但我只是菜鸟来着，完全不会Debug......

rednaxela

尝试编译krkr2么？（苦笑
那里面boost应该不是带来什么麻烦，如果你用对了版本的话。麻烦是麻烦在另外的一些依赖上吧。我极其厌恶的一些东西，例如VCL什么的……也有一些库被稍微改过？这个得问问米粒看他知不知道。

C不是强类型……==，什么是强类型？
另外D里的delegate比C的函数指针安全么？hmm...没看出来。

Delegates are an aggregate of two pieces of data: an object reference and a function pointer.

===========================我是分隔线============================

委托带有它周围的环境信息，在有很多类的时候，比较不容易指错地方。

这个值得商榷。能给出一个例子，来说明一下怎样会指错，而D里的delegate如何协助不指错吗？

shawind

我是卡在了boost上，后面就没有耐心去做了。

c或许也算强类型的一种，可是在D中声明了struct,class后，就可以把它当作新的数据类型来使用，还有D中用typedef int i; 把i当作一个全新的类型，c中的类型显然是没有这么“强”的。

委托的例子的话，就比如说，有两个类，一个是人物A，一个是人物B，都有一个类似的方法，move(int x, int y); 如果我要区别使用这两方法，用委托应该比用函数指针好吧。我是这么想的，还没有做过这样的实验。

rednaxela

根据米粒的指导，用Boost 1.30基本上没出什么问题……不过始终我还是编译不出krkr2的内核的。也罢。
Alright,那来看看：

1. class A {
2.     bool move(int x, int y) {
3.         return true;
4.     }
5. }
7. class B {
8.     bool move(int x, int y) {
9.         return false;
10.     }
11. }
13. bool delegate(int, int) dg;
15. void main(char[][] args) {
16.     A a = new A;
17.     B b = new B;
18.     dg = &a.move;
19.     printf("%d\\n", dg(1, 2));
20.     dg = &b.move;
21.     printf("%d\\n", dg(3, 4));
22. }

复制代码

并没有区别A与B。事实上函数指针就该这么用。对一个函数指针或者委托，重要的只是参数个数和类型，以及返回类型；至于所指向的成员方法属于什么类型的类，不是函数指针需要关心的。