Từ 1 tới 9 trên tổng số 9 kết quả

Đề tài: làm 1 cái đồng hồ số

  1. #1
    Ngày gia nhập
    05 2008
    Bài viết
    1

    Wink làm 1 cái đồng hồ số

    mình muốn làm 1 cái đồng hồ số để hiển thị trên màn hình.Xin hỏi anh chị em nào có thể giúp được không ạ?
    Xin cảm ơn!

  2. #2
    Ngày gia nhập
    06 2007
    Nơi ở
    C:\WINDOWS\system32\dllcache\
    Bài viết
    3,006

    Về vấn đề này :

    Lặp :
    {
    + Lấy time từ hệ thống .
    + Viết lên màn hình.
    }

    ....

    Lặp : nhớ cho điều kiện dừng .!

    Lấy time từ hệ thống :
    void gettime(struct time *t);

    với cấu trúc time được định nghĩa sẵn trong dos.h :
    struct time
    {
    unsiged ti_hour;
    unsiged ti_min;
    unsiged ti_sec;
    unsiged ti_hund; //mili giây
    }


    + viết lên màn hình :
    viết giá trị lên màn hình tại 1 ví trị cố định ( xài gotoxy )

    hết.
    ( Tôi ko có quyền code hộ bạn )
    ^_,^

    Tổng hợp các câu chuyện hài hước vui nhộn, sử dụng Speech Synthesis để đọc : https://www.youtube.com/channel/UCLk...Tjrg/playlists


    Bùi Tấn Quang

  3. #3
    Ngày gia nhập
    05 2008
    Bài viết
    6

    mình không biết superman dùng ngôn ngữ gì để làm, nên mình chỉ nói ý tưởng của mình cho "siêu nhân " nghe chơi nè...

    Theo như vòng tròn Sin_Cos thì nguyên vòng tròn là 2PI, như vậy tương đương 60 giây (chia cái đồng hồ là 60 vạch) tương đương 2 PI. Vậy cứ 1 giây (1 vạch) thì góc sẽ là 1*2PI/60 => góc cho kim giây tại 1 thời điễm tức thời (ví dụ là đang đến giây thứ 5) có góc bằng 5*PI/30. Từ đó dùng thêm hàm dateTime.now.hour (trong C#) để lấy số giây hiện tại và áp vào cái biểu thức như tr6n thì sẽ có góc cho kim giây.
    Bạn suy diễn tương tự để lấy góc nhảy cho kim giờ và kim phút.

    Sau đó bạn cần lưu ý đến tọa độ đỉnh cho các kim (toạc độ gốc cho các kim là vị trí giữa đồng hồ nên cố định rồi). Bạn sẽ thay cos bằng sin và thay sin bằng cos của góc kim giây ngay tại thời điểm nào đó để xác định toại độ đỉnh của cây kim, vì theo vòng tròn lượng giác, điễm đầu tiên là góc 90 độ so với điểm đầu tiên của đồng hồ. Khi bạn tính ra góc như bước trên tức là bạn đã tính so với đi63m đầu của vòng lương giác. Để quy về như đồng hồ, ta phải có thao tác chuyển 1 chút.

    Mình học C# , không biết bạn viết bằng cái gì!
    Code:
    gocGiay = s * Math.PI / 30.0; 
    gocPhut = m * Math.PI / 30.0 ; 
    gocGio = h * Math.PI / 6.0 ;
    
    //các số ghi bên dưới là khoảng cách từ gốc đồng hổ đến ngọn kim(chiều dài kim)
    Point pkimGiay = new Point((int)(64 * Math.Sin(gocGiay) + po.X), (int)(-64 * Math.Cos(gocGiay) + po.Y));
    Point pkimPhut = new Point((int)(55 * Math.Sin(gocPhut) + po.X), (int)(-55 * Math.Cos(gocPhut) + po.Y));
    Point pkimGio = new Point((int)(40 * Math.Sin(gocGio) + po.X), (int)(-40 * Math.Cos(gocGio) + po.Y));
    Code đó là những gì cơ bản nhất. Ngoài ra bạn muốn đồng hồ của bạn chạy mượt mà, êm ả thì bạn cần bỏ thêm vài phụ gia và chút tư duy của bạn.
    (Mình sợ giờ mà bỏ vào luôn thì bạn bó tay, khỏi hiểu code luôn, nên mình chỉ bõ vào phần nào thiết yếu nhát thôi).
    Chúc bạn thành công.
    Đã được chỉnh sửa lần cuối bởi kaka11d : 12-05-2008 lúc 05:20 PM.
    Ngu 3 năm , khôn 1 giờ
    1 giờ đủ làm nên mọi chuyện

  4. #4
    Ngày gia nhập
    10 2007
    Nơi ở
    /root
    Bài viết
    318

    Trích dẫn Nguyên bản được gửi bởi langman Xem bài viết
    Về vấn đề này :

    Lặp :
    {
    + Lấy time từ hệ thống .
    + Viết lên màn hình.
    }
    Xin hỏi langman là sẽ lặp tới ... bao giờ ?
    Giả sử tớ muốn có đồng hồ hiển thị giờ , phút , giây .Nếu như lấy giờ hệ thống và hiển thị lên màn hình nhờ vòng lặp thì ai đảm bảo rằng mỗi giây đồng hồ sẽ được update 1 lần ? Mỗi vòng lặp chạy mất 1 giây ????
    Đã được chỉnh sửa lần cuối bởi Tab : 12-05-2008 lúc 05:26 PM.

  5. #5
    Ngày gia nhập
    06 2007
    Nơi ở
    C:\WINDOWS\system32\dllcache\
    Bài viết
    3,006

    :|
    theo mình thì mình suy nghĩ thế này nè.

    @kaka11d : người ta hỏi đồng hồ số mà.

    @ void main :

    + lặp đến khi nào chán :| ví dụ alt + f4, ESC , exit ....

    + Việc lấy time và src ra màn hình mất lượng thời gian cực thấp. nên việc lấy thời gian viết ra màn hình hầu như ko đáng kể. còn việc bảo đảm cho 1s nó update 1 lần thì có gì khó........ pó tay. delay(1000) ví dụ thế.
    tôi bảo đảm rằng cách này hoàn toàn chính xác ko có gì sai cả.

    nếu giờ hệ thống mà sai thì tất nhiên nó sai rồi
    nếu giờ hệ thống đúng thì hiển nhiên nó cũng đúng. Chả bao giờ lệch đi đâu cả.
    ^_,^

    Tổng hợp các câu chuyện hài hước vui nhộn, sử dụng Speech Synthesis để đọc : https://www.youtube.com/channel/UCLk...Tjrg/playlists


    Bùi Tấn Quang

  6. #6
    Ngày gia nhập
    06 2007
    Nơi ở
    C:\WINDOWS\system32\dllcache\
    Bài viết
    3,006

    Mặc định làm 1 cái đồng hồ số

    giả sử ở lần 1:

    +lấy time
    +hiển thị

    mất 3 mili giây

    ở lần 2 (sau 1000mili giây) : cái 3mili giây đấy chả có ý nghĩa gì cả vì nó lấy time tại thời điểm tức thời. ( ngay lúc lấy time) không còn liên quan gì với 3mili giây đó


    Về nguyên tắc nếu bạn đặt giờ system mà đúng thì chả bao giờ nó chạy sai cả.
    ^_,^

    Tổng hợp các câu chuyện hài hước vui nhộn, sử dụng Speech Synthesis để đọc : https://www.youtube.com/channel/UCLk...Tjrg/playlists


    Bùi Tấn Quang

  7. #7
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Tham khảo code sau đây :
    clock.h
    C Code:
    1.  
    2. /*         TSR.H    */
    3.  
    4. #include <dos.h>
    5.  
    6. union REGS i,o;
    7. struct SREGS s;
    8.  
    9. int r,c,k;
    10. char far *scr=(char far*)0xB8000000L,*buffer;
    11.  
    12.  
    13. /* Writes a char */
    14. writechar(char ch,int row,int col,int attb)
    15. {
    16.     *(scr+row*160+col*2)=ch;
    17.     *(scr+row*160+col*2+1)=attb;
    18.     return 0;
    19. }
    20.  
    21.  
    22.  
    23. /* Writes a string at a given location on screen in given attribute   */
    24. writestring(char *str,int row,int col,int attb)
    25. {
    26.     while (*str)
    27.     {
    28.         writechar(*str,row,col,attb);
    29.         str++;
    30.         col++;
    31.     }
    32.     return 0;
    33. }
    34.  
    35.  
    36.  
    37.  
    38. /* clears a window on screen with given attribute */
    39.  
    40. clrwin(int sr,int sc,int er,int ec,int attb)
    41. {
    42.     i.h.ah=6;
    43.     i.h.al=0;
    44.     i.h.ch=sr;
    45.     i.h.cl=sc;
    46.     i.h.dh=er;
    47.     i.h.dl=ec;
    48.     i.h.bh=attb;
    49.     int86(0x10,&i,&i);
    50.     return 0;
    51.  
    52. }
    53.  
    54.  
    55. /* saves a window on screen */
    56. savevideo(int sr,int sc,int er,int ec)
    57. {
    58.     for (k=0,r=sr;r<=er;r++)
    59.     {
    60.         for (c=sc;c<=ec;c++)
    61.         {
    62.             /* buffer is global pointer pointing to area allocated using malloc() */
    63.             buffer[k]=*(scr+r*160+c*2);
    64.             buffer[k+1]=*(scr+r*160+c*2+1);
    65.             k+=2;
    66.         }
    67.     }
    68.     return 0;
    69. }
    70.  
    71.  
    72. /*restores a window on screen */
    73. restorevideo(int sr,int sc,int er,int ec)
    74. {
    75.     for (k=0,r=sr;r<=er;r++)
    76.     {
    77.         for (c=sc;c<=ec;c++)
    78.         {
    79.             *(scr+r*160+c*2)=buffer[k];
    80.             *(scr+r*160+c*2+1)=buffer[k+1];
    81.             k+=2;
    82.         }
    83.     }
    84.     return 0;
    85. }
    86.  
    87.  
    88.  
    89. movevideo(int sr,int sc,int er,int ec,int srm,int scm)
    90. {
    91.     for (k=0,r=srm;r<=srm+er-sr;r++)
    92.     {
    93.         for (c=scm;c<=scm+ec-sc;c++)
    94.         {
    95.             *(scr+r*160+c*2)=buffer[k];
    96.             *(scr+r*160+c*2+1)=buffer[k+1];
    97.             k+=2;
    98.         }
    99.     }
    100.     return 0;
    101. }
    102.  
    103.  
    104. warp(int xx)
    105. {
    106.     int iii;
    107.     for (iii=0;iii<4000;iii+=2)
    108.         *(scr+iii)=xx;
    109.     return 0;
    110.  
    111. }
    112.  
    113.  
    114. typeit(int sr,int sc,int len,char *a)
    115. {
    116.     r=sr;
    117.     c=sc;
    118.     for (c=sc;c<=sc+len-1;c++)
    119.     {
    120.         *(scr+r*160+c*2)=*a;
    121.         a++;
    122.     }
    123.     return 0;
    124. }

    Clock.c
    C Code:
    1. #include <dos.h>
    2. #include <tsr.h>
    3.  
    4. void interrupt (*prevtimer)();
    5. void interrupt mytimer();
    6. int running=0;
    7. //int io=0,hours,sec,min;
    8. unsigned long int far *time=(unsigned long far *)0x46C;
    9. char far *scr;
    10. char far *mode;
    11. //struct time t;
    12. void main()
    13. {
    14.     if ((*mode & 0x30)==0x30)
    15.         scr=(char far *)0xB0000000L;
    16.     else
    17.         scr=(char far *)0xB8000000L;
    18.     /*if(io==0)
    19.     {
    20.     gettime(&t);
    21.     hours=t.ti_hour;//(*time/65520);
    22.     min=t.ti_min;//(*time - hours*65520)/1092;
    23.     sec=t.ti_sec;//(*time-(hours*65520)-(min*1092))*10/182;
    24.     io++;
    25.     } */
    26.     prevtimer=getvect(8);
    27.     setvect(8,mytimer);
    28.     keep(0,1000);
    29. }
    30.  
    31.  
    32. void interrupt mytimer()
    33. {
    34.     unsigned char hours,min,sec;
    35.     if (running==0)
    36.     {
    37.         running=1;
    38.         hours=(*time/65520);
    39.         min=(*time - hours*65520)/1092;
    40.         sec=(*time-(hours*65520)-(min*1092))*10/182;
    41.  
    42.         if (sec>=60)
    43.         {
    44.             sec-=60;
    45.             min++;
    46.  
    47.             if (min==60)
    48.             {
    49.                 min=0;
    50.                 hours++;
    51.                 if (hours==24)
    52.                     hours=0;
    53.             }
    54.         }
    55.  
    56.  
    57.         writechar(48+hours/10,0,72,66);
    58.         writechar(48+hours%10,0,73,66);
    59.         writechar(':',0,74,66);
    60.         writechar(48+min/10,0,75,66);
    61.         writechar(48+min%10,0,76,66);
    62.         writechar(':',0,77,66);
    63.         writechar(48+sec/10,0,78,66);
    64.         writechar(48+sec%10,0,79,66);
    65.         writestring("Made by AAKASH DEEP MANDHAR ",0,44,66);
    66.         running=0;
    67.     }
    68.     (*prevtimer)();
    69. }

  8. #8
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Học openGL rùi thì coi luôn cái này ( 3D clock )
    C++ Code:
    1. /*
    2.  *
    3.  * This code is (c) by Andrei Krotkov.
    4.  * The base fot this code was made through
    5.  * the tutorials at nehe.gamedev.net.
    6.  *
    7.  */
    8.  
    9. #pragma comment(lib, "winmm.lib")
    10.  
    11. #define WIN32_LEAN_AND_MEAN
    12. #include <windows.h>
    13. #include <stdio.h>
    14. #include <stdlib.h>
    15. #include <math.h>
    16. #include <fstream.h>
    17. #include <mmsystem.h>
    18. #include <time.h>
    19.  
    20. #include <gl\gl.h>         
    21. #include <gl\glu.h>    
    22. #include <gl\glaux.h>
    23.  
    24. HDC         hDC=NULL;      
    25. HGLRC       hRC=NULL;  
    26. HWND        hWnd=NULL;     
    27. HINSTANCE   hInstance;     
    28.  
    29. bool    active=true;
    30. bool    fullscreen=false;
    31.  
    32. const float piover180 = 0.0174532925f;
    33. const float onesix = .0625f;
    34.  
    35. int screennum=0;
    36.  
    37. DWORD ticks=0;
    38. long int frames=0;
    39. int fps=0;
    40.  
    41. GLuint texture[15];
    42. GLfloat color[]={0,0,0,0};
    43.  
    44. int rot[9]={-18,-18,-18,-18,-18,-18,-18,-18,-18};
    45. int dat[9]={0,0,0,0,0,0,0,0,0};
    46.  
    47. int timev=0;
    48.  
    49. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);  
    50.  
    51. void drawwheel(int num)
    52. {
    53.  
    54.     int x=0;
    55.     glEnable(GL_TEXTURE_2D);
    56.     glBindTexture(GL_TEXTURE_2D, texture[0]);
    57.     glBegin(GL_QUADS);
    58.     for (int dir=0;dir<360;dir+=36)
    59.     {
    60.         if (x==num)
    61.         {
    62.             glColor3f(1,0,0);
    63.         }
    64.         else
    65.         {
    66.             glColor3f(1,1,1);
    67.         }
    68.         glTexCoord2f(.0625*x,1-.0625);
    69.         glVertex3f(cos(dir*piover180),sin(dir*piover180),.5);
    70.         glTexCoord2f(.0625*(x+1),1-.0625);
    71.         glVertex3f(cos(dir*piover180),sin(dir*piover180),-.5);
    72.         glTexCoord2f(.0625*(x+1),1);
    73.         glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),-.5);
    74.         glTexCoord2f(.0625*x,1);
    75.         glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),.5);
    76.         x++;
    77.     }
    78.     glEnd();
    79. }
    80.  
    81. void drawcolon()
    82. {
    83.     int x=0;
    84.     glEnable(GL_TEXTURE_2D);
    85.     glBindTexture(GL_TEXTURE_2D, texture[0]);
    86.     glBegin(GL_QUADS);
    87.     for (int dir=0;dir<360;dir+=36)
    88.     {
    89.         if (x==0)
    90.         {
    91.             glColor3f(1,0,0);
    92.         }
    93.         else
    94.         {
    95.             glColor3f(1,1,1);
    96.         }      
    97.         glTexCoord2f(.0625*11,1-.0625);
    98.         glVertex3f(cos(dir*piover180),sin(dir*piover180),.5);
    99.         glTexCoord2f(.0625*(11+1),1-.0625);
    100.         glVertex3f(cos(dir*piover180),sin(dir*piover180),-.5);
    101.         glTexCoord2f(.0625*(11+1),1);
    102.         glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),-.5);
    103.         glTexCoord2f(.0625*11,1);
    104.         glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),.5);
    105.         x++;
    106.     }
    107.     glEnd();
    108. }
    109.  
    110. void drawpmam(bool pm)
    111. {
    112.     int x=0;
    113.     glEnable(GL_TEXTURE_2D);
    114.     glBindTexture(GL_TEXTURE_2D, texture[0]);
    115.     glBegin(GL_QUADS);
    116.     for (int dir=0;dir<360;dir+=36)
    117.     {
    118.         if (x==0)
    119.         {
    120.             glColor3f(1,0,0);
    121.         }
    122.         else
    123.         {
    124.             glColor3f(1,1,1);
    125.         }      
    126.         if (pm)
    127.         {
    128.             glTexCoord2f(.0625*12,1-.0625);
    129.             glVertex3f(cos(dir*piover180),sin(dir*piover180),.5);
    130.             glTexCoord2f(.0625*(12+1),1-.0625);
    131.             glVertex3f(cos(dir*piover180),sin(dir*piover180),-.5);
    132.             glTexCoord2f(.0625*(12+1),1);
    133.             glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),-.5);
    134.             glTexCoord2f(.0625*12,1);
    135.             glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),.5);
    136.         }
    137.         else
    138.         {
    139.             glTexCoord2f(.0625*13,1-.0625);
    140.             glVertex3f(cos(dir*piover180),sin(dir*piover180),.5);
    141.             glTexCoord2f(.0625*(13+1),1-.0625);
    142.             glVertex3f(cos(dir*piover180),sin(dir*piover180),-.5);
    143.             glTexCoord2f(.0625*(13+1),1);
    144.             glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),-.5);
    145.             glTexCoord2f(.0625*13,1);
    146.             glVertex3f(cos((dir+36)*piover180),sin((dir+36)*piover180),.5);
    147.         }
    148.         x++;
    149.     }
    150.     glEnd();
    151. }
    152.  
    153. int DrawGLScene(void)                                  
    154. {
    155.     // int hour10=0,hour1=0,min10=0,min1=0,sec10=0,sec1=0;
    156.     int hours=0, minutes=0, seconds=0;
    157.     bool pm=true;
    158.     timev=time(NULL);
    159.     timev%=86400;
    160.     if (timev<43200)
    161.         pm=false;
    162.     hours=timev/3600;
    163.     timev%=3600;
    164.     minutes=timev/60;
    165.     timev%=60;
    166.     seconds=timev;
    167.  
    168.     hours-=4;
    169.     hours+=12;
    170.     hours%=12;
    171.  
    172.     rot[1]=360-((seconds%10)*36+18);
    173.     dat[1]=seconds%10;
    174.     rot[2]=360-((seconds/10)*36+18+((seconds%10)/10.0)*36.0f);
    175.     dat[2]=seconds/10;
    176.     // rot[3] is a colon
    177.     rot[4]=360-((minutes%10)*36+18+((seconds/10)/6.0)*36.0f);
    178.     dat[4]=minutes%10;
    179.     rot[5]=360-((minutes/10)*36+18+((minutes%10)/10.0)*36.0f);
    180.     dat[5]=minutes/10;
    181.     // rot[6] is a colon
    182.     rot[7]=360-((hours%10)*36+18+((minutes/10)/6.0)*36.0f);
    183.     dat[7]=hours%10;
    184.     rot[8]=360-((hours/10)*36+18+((hours%10)/10.0)*36.0f);
    185.     dat[8]=hours/10;
    186.  
    187.     if (screennum==0)
    188.     {
    189.         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    190.         glLoadIdentity();
    191.         gluLookAt(20,0,4.5,
    192.                   0,0,4.5,
    193.                   0,1,0);
    194.         for (int x=0;x<9;x++)
    195.         {
    196.             glTranslatef(0,0,1);
    197.             glRotatef(rot[x],0,0,1);
    198.             if ((x!=3)&(x!=6)&&(x!=0))
    199.             {  
    200.                 drawwheel(dat[x]);
    201.             }
    202.             else
    203.             {
    204.                 if (x!=0)
    205.                     drawcolon();
    206.                 else
    207.                     drawpmam(pm);
    208.             }
    209.             glRotatef(rot[x],0,0,-1);
    210.         }
    211.     }                      
    212.     return true;                                   
    213. }
    214.  
    215. void ReSizeGLScene(GLsizei width, GLsizei height)  
    216. {
    217.     glViewport(0,0,width,height);                  
    218.  
    219.     glMatrixMode(GL_PROJECTION);                   
    220.     glLoadIdentity();                              
    221.    
    222.     gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
    223.  
    224.     glMatrixMode(GL_MODELVIEW);                        
    225.     glLoadIdentity();                                  
    226. }
    227.  
    228. AUX_RGBImageRec *LoadBMP(char *Filename)                // Loads A Bitmap Image
    229. {
    230.         FILE *File=NULL;                                // File Handle
    231.  
    232.         if (!Filename)                                  // Make Sure A Filename Was Given
    233.         {
    234.                 return NULL;                            // If Not Return NULL
    235.         }
    236.  
    237.         File=fopen(Filename,"r");                       // Check To See If The File Exists
    238.  
    239.         if (File)                                       // Does The File Exist?
    240.         {
    241.                 fclose(File);                           // Close The Handle
    242.                 return auxDIBImageLoad(Filename);       // Load The Bitmap And Return A Pointer
    243.         }
    244.         return NULL;                                    // If Load Failed Return NULL
    245. }
    246.  
    247. void LoadGLTextures()                                    // Load Bitmaps And Convert To Textures
    248. {
    249.         char input[200];
    250.         char buffer[200];
    251.    
    252.         int num=0;
    253.  
    254.         ifstream fin("graphics/textures.txt");
    255.         fin>>num;
    256.         for (int i=0;i<num;i++)
    257.         {
    258.             fin>>input;
    259.             wsprintf(buffer,"graphics/%s",input);
    260.             AUX_RGBImageRec *TextureImage[1];               // Create Storage Space For The Texture
    261.  
    262.             memset(TextureImage,0,sizeof(void *)*1);        // Set The Pointer To NULL
    263.  
    264.             // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
    265.             if (TextureImage[0]=auxDIBImageLoad(buffer))
    266.             {
    267.                     glGenTextures(1, &texture[i]);          // Create Three Textures
    268.  
    269.                     glBindTexture(GL_TEXTURE_2D, texture[i]);
    270.                     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    271.                     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
    272.                     gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
    273.             }
    274.             if (TextureImage[0])                            // If Texture Exists
    275.             {
    276.                     if (TextureImage[0]->data)              // If Texture Image Exists
    277.                     {
    278.                             free(TextureImage[0]->data);    // Free The Texture Image Memory
    279.                     }
    280.  
    281.                     free(TextureImage[0]);                  // Free The Image Structure
    282.             }
    283.         }
    284. }
    285.  
    286. int InitGL(void)                                   
    287. {
    288.     LoadGLTextures();
    289.     glShadeModel(GL_SMOOTH);                       
    290.     glClearColor(0.0f, 0.0f,0.0f, 0.0f);               
    291.     glClearDepth(1.0f);    
    292.     glEnable(GL_DEPTH_TEST);                           
    293.     glDepthFunc(GL_LEQUAL);                        
    294.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    295.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    296.  
    297.     return true;
    298. }
    299.  
    300.  
    301. void KillGLWindow(void)                        
    302. {
    303.     if (fullscreen)                                
    304.     {
    305.         ChangeDisplaySettings(NULL,0);         
    306.         ShowCursor(true);                  
    307.     }
    308.  
    309.     if (hRC)                                       
    310.     {
    311.         if (!wglMakeCurrent(NULL,NULL))            
    312.         {
    313.             MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
    314.         }
    315.  
    316.         if (!wglDeleteContext(hRC))                
    317.         {
    318.             MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
    319.         }
    320.         hRC=NULL;                                  
    321.     }
    322.  
    323.     if (hDC && !ReleaseDC(hWnd,hDC))                   
    324.     {
    325.         MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
    326.         hDC=NULL;                                  
    327.     }
    328.  
    329.     if (hWnd && !DestroyWindow(hWnd))                  
    330.     {
    331.         MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
    332.         hWnd=NULL;                                 
    333.     }
    334.  
    335.     if (!UnregisterClass("OpenGL",hInstance))      
    336.     {
    337.         MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
    338.         hInstance=NULL;                            
    339.     }
    340. }
    341.  
    342. BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
    343. {
    344.     GLuint      PixelFormat;       
    345.     WNDCLASS    wc;                    
    346.     DWORD       dwExStyle;             
    347.     DWORD       dwStyle;           
    348.     RECT        WindowRect;            
    349.     WindowRect.left=(long)0;       
    350.     WindowRect.right=(long)width;  
    351.     WindowRect.top=(long)0;        
    352.     WindowRect.bottom=(long)height;
    353.  
    354.     fullscreen=fullscreenflag;         
    355.  
    356.     hInstance           = GetModuleHandle(NULL);           
    357.     wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    358.     wc.lpfnWndProc      = (WNDPROC) WndProc;               
    359.     wc.cbClsExtra       = 0;                                   
    360.     wc.cbWndExtra       = 0;                               
    361.     wc.hInstance        = hInstance;                       
    362.     wc.hIcon            = LoadIcon(NULL, IDI_WINLOGO);     
    363.     wc.hCursor          = LoadCursor(NULL, IDC_ARROW);     
    364.     wc.hbrBackground    = NULL;                            
    365.     wc.lpszMenuName     = NULL;                            
    366.     wc.lpszClassName    = "OpenGL";                    
    367.  
    368.     if (!RegisterClass(&wc))                               
    369.     {
    370.         MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    371.         return false;                                      
    372.     }
    373.    
    374.     if (fullscreen)                                        
    375.     {
    376.         DEVMODE dmScreenSettings;                          
    377.         memset(&dmScreenSettings,0,sizeof(dmScreenSettings));  
    378.         dmScreenSettings.dmSize=sizeof(dmScreenSettings);      
    379.         dmScreenSettings.dmPelsWidth    = width;           
    380.         dmScreenSettings.dmPelsHeight   = height;          
    381.         dmScreenSettings.dmBitsPerPel   = bits;            
    382.         dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
    383.  
    384.         if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
    385.         {
    386.             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)
    387.             {
    388.                 fullscreen=false;  
    389.             }
    390.             else
    391.             {
    392.                 MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
    393.                 return false;                              
    394.             }
    395.         }
    396.     }
    397.  
    398.     if (fullscreen)                                        
    399.     {
    400.         dwExStyle=WS_EX_APPWINDOW;                             
    401.         dwStyle=WS_POPUP;                                  
    402.         ShowCursor(false);                                 
    403.     }
    404.     else
    405.     {
    406.         dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;      
    407.         dwStyle=WS_OVERLAPPEDWINDOW;                       
    408.     }
    409.  
    410.     AdjustWindowRectEx(&WindowRect, dwStyle, false, dwExStyle);
    411.  
    412.  
    413.     if (!(hWnd=CreateWindowEx(  dwExStyle,                         
    414.                                 "OpenGL",                      
    415.                                 title,                         
    416.                                 dwStyle |                          
    417.                                 WS_CLIPSIBLINGS |              
    418.                                 WS_CLIPCHILDREN,               
    419.                                 0, 0,                              
    420.                                 WindowRect.right-WindowRect.left,  
    421.                                 WindowRect.bottom-WindowRect.top,
    422.                                 NULL,                          
    423.                                 NULL,                          
    424.                                 hInstance,                     
    425.                                 NULL)))                        
    426.     {
    427.         KillGLWindow();                        
    428.         MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    429.         return false;                          
    430.     }
    431.  
    432.     static  PIXELFORMATDESCRIPTOR pfd=         
    433.     {
    434.         sizeof(PIXELFORMATDESCRIPTOR),         
    435.         1,                                     
    436.         PFD_DRAW_TO_WINDOW |                   
    437.         PFD_SUPPORT_OPENGL |                   
    438.         PFD_DOUBLEBUFFER,                      
    439.         PFD_TYPE_RGBA,                             
    440.         bits,                                  
    441.         0, 0, 0, 0, 0, 0,                      
    442.         0,                                     
    443.         0,                                     
    444.         0,                                     
    445.         0, 0, 0, 0,                            
    446.         16,                                  
    447.         0,                                     
    448.         0,                                         
    449.         PFD_MAIN_PLANE,                        
    450.         0,                                     
    451.         0, 0, 0                                
    452.     };
    453.    
    454.     if (!(hDC=GetDC(hWnd)))                    
    455.     {
    456.         KillGLWindow();                    
    457.         MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    458.         return false;                          
    459.     }
    460.  
    461.     if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))
    462.     {
    463.         KillGLWindow();                            
    464.         MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    465.         return false;                      
    466.     }
    467.  
    468.     if(!SetPixelFormat(hDC,PixelFormat,&pfd))
    469.     {
    470.         KillGLWindow();                        
    471.         MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    472.         return false;                          
    473.     }
    474.  
    475.     if (!(hRC=wglCreateContext(hDC)))          
    476.     {
    477.         KillGLWindow();                            
    478.         MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    479.         return false;                          
    480.     }
    481.  
    482.     if(!wglMakeCurrent(hDC,hRC))                   
    483.     {
    484.         KillGLWindow();                            
    485.         MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    486.         return false;                  
    487.     }
    488.  
    489.     ShowWindow(hWnd,SW_SHOW);                  
    490.     SetForegroundWindow(hWnd);                 
    491.     SetFocus(hWnd);                            
    492.     ReSizeGLScene(width, height);              
    493.  
    494.     if (!InitGL())                                 
    495.     {
    496.         KillGLWindow();                        
    497.         MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    498.         return false;                          
    499.     }
    500.  
    501.     return true;                               
    502. }
    503.  
    504. LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)           
    505. {
    506.     switch (uMsg)                                  
    507.     {
    508.         case WM_ACTIVATE:                      
    509.         {
    510.             if (!HIWORD(wParam))               
    511.             {
    512.                 active=true;                   
    513.             }
    514.             else
    515.             {
    516.                 active=false;                      
    517.             }
    518.         }
    519.         break;
    520.         case WM_SYSCOMMAND:                    
    521.         {
    522.             switch (wParam)                    
    523.             {
    524.                 case SC_SCREENSAVE:            
    525.                 case SC_MONITORPOWER:          
    526.                 return 0;                      
    527.             }
    528.             break;                             
    529.         }
    530.  
    531.         case WM_CLOSE:                             
    532.         {
    533.             PostQuitMessage(0);                    
    534.             return 0;                  
    535.         }
    536.  
    537.         case WM_SIZE:                              
    538.         {
    539.             ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  
    540.             return 0;                              
    541.         }
    542.  
    543.         case WM_KEYDOWN:
    544.             {
    545.  
    546.             }
    547.             break;
    548.     }
    549.  
    550.     return DefWindowProc(hWnd,uMsg,wParam,lParam);
    551. }
    552.  
    553. int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine,int nShowCmd)
    554. {
    555.     MSG     msg;                               
    556.     BOOL    done=false;        
    557.  
    558.     if (!CreateGLWindow("3D RPG DEMO",640,480,16,fullscreen))
    559.     {
    560.         return 0;                              
    561.     }
    562.  
    563.     while(!done)                               
    564.     {
    565.         if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))  
    566.         {
    567.             if (msg.message==WM_QUIT)              
    568.             {
    569.                 done=true;                     
    570.             }
    571.             else                               
    572.             {
    573.                 TranslateMessage(&msg);        
    574.                 DispatchMessage(&msg);     
    575.             }
    576.         }
    577.         else                                   
    578.         {
    579.             if (active)                        
    580.             {
    581.                 if (GetAsyncKeyState(VK_ESCAPE)!=0)        
    582.                 {
    583.                     done=true;                     
    584.                 }
    585.                 else                               
    586.                 {
    587.                     DrawGLScene();
    588.                     SwapBuffers(hDC);                              
    589.                 }
    590.             }
    591.         }
    592.     }
    593.  
    594.     KillGLWindow();                            
    595.     return (msg.wParam);                       
    596. }

  9. #9
    Ngày gia nhập
    05 2008
    Bài viết
    6

    ủa, nhầm >.< sorry, thì ra là bạn viết C, mình thấy bài trên phần "bài viết mới" nên không để ý tới mục của bạn là hỏi đáp về C >.<.

    mà cái đồng hồ số bên C làm vất vưỡng vậy ư >.< pó chiếu.

    Tớ không biết về C (mà chỉe biết C#) nên mấy bạn thông củm. hehe
    Đồng hồ số trong C# có 3 hàng để cho ra giờ (1 hàng) phút (1 hàng) giấy (1 hàng) .
    Ngu 3 năm , khôn 1 giờ
    1 giờ đủ làm nên mọi chuyện

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn